1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2019 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 "common/filestuff.h"
46 #include "common/rsp-low.h"
50 #include "common/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 "common/agent.h"
73 #include "record-btrace.h"
75 #include "common/scoped_restore.h"
76 #include "common/environ.h"
77 #include "common/byte-vector.h"
78 #include <unordered_map>
80 /* The remote target. */
82 static const char remote_doc
[] = N_("\
83 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
84 Specify the serial device it is connected to\n\
85 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
87 #define OPAQUETHREADBYTES 8
89 /* a 64 bit opaque identifier */
90 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
92 struct gdb_ext_thread_info
;
93 struct threads_listing_context
;
94 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
95 struct protocol_feature
;
99 typedef std::unique_ptr
<stop_reply
> stop_reply_up
;
101 /* Generic configuration support for packets the stub optionally
102 supports. Allows the user to specify the use of the packet as well
103 as allowing GDB to auto-detect support in the remote stub. */
107 PACKET_SUPPORT_UNKNOWN
= 0,
112 /* Analyze a packet's return value and update the packet config
122 struct threads_listing_context
;
124 /* Stub vCont actions support.
126 Each field is a boolean flag indicating whether the stub reports
127 support for the corresponding action. */
129 struct vCont_action_support
144 /* About this many threadisds fit in a packet. */
146 #define MAXTHREADLISTRESULTS 32
148 /* Data for the vFile:pread readahead cache. */
150 struct readahead_cache
152 /* Invalidate the readahead cache. */
155 /* Invalidate the readahead cache if it is holding data for FD. */
156 void invalidate_fd (int fd
);
158 /* Serve pread from the readahead cache. Returns number of bytes
159 read, or 0 if the request can't be served from the cache. */
160 int pread (int fd
, gdb_byte
*read_buf
, size_t len
, ULONGEST offset
);
162 /* The file descriptor for the file that is being cached. -1 if the
166 /* The offset into the file that the cache buffer corresponds
170 /* The buffer holding the cache contents. */
171 gdb_byte
*buf
= nullptr;
172 /* The buffer's size. We try to read as much as fits into a packet
176 /* Cache hit and miss counters. */
177 ULONGEST hit_count
= 0;
178 ULONGEST miss_count
= 0;
181 /* Description of the remote protocol for a given architecture. */
185 long offset
; /* Offset into G packet. */
186 long regnum
; /* GDB's internal register number. */
187 LONGEST pnum
; /* Remote protocol register number. */
188 int in_g_packet
; /* Always part of G packet. */
189 /* long size in bytes; == register_size (target_gdbarch (), regnum);
191 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
195 struct remote_arch_state
197 explicit remote_arch_state (struct gdbarch
*gdbarch
);
199 /* Description of the remote protocol registers. */
200 long sizeof_g_packet
;
202 /* Description of the remote protocol registers indexed by REGNUM
203 (making an array gdbarch_num_regs in size). */
204 std::unique_ptr
<packet_reg
[]> regs
;
206 /* This is the size (in chars) of the first response to the ``g''
207 packet. It is used as a heuristic when determining the maximum
208 size of memory-read and memory-write packets. A target will
209 typically only reserve a buffer large enough to hold the ``g''
210 packet. The size does not include packet overhead (headers and
212 long actual_register_packet_size
;
214 /* This is the maximum size (in chars) of a non read/write packet.
215 It is also used as a cap on the size of read/write packets. */
216 long remote_packet_size
;
219 /* Description of the remote protocol state for the currently
220 connected target. This is per-target state, and independent of the
221 selected architecture. */
230 /* Get the remote arch state for GDBARCH. */
231 struct remote_arch_state
*get_remote_arch_state (struct gdbarch
*gdbarch
);
235 /* A buffer to use for incoming packets, and its current size. The
236 buffer is grown dynamically for larger incoming packets.
237 Outgoing packets may also be constructed in this buffer.
238 The size of the buffer is always at least REMOTE_PACKET_SIZE;
239 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
241 gdb::char_vector buf
;
243 /* True if we're going through initial connection setup (finding out
244 about the remote side's threads, relocating symbols, etc.). */
245 bool starting_up
= false;
247 /* If we negotiated packet size explicitly (and thus can bypass
248 heuristics for the largest packet size that will not overflow
249 a buffer in the stub), this will be set to that packet size.
250 Otherwise zero, meaning to use the guessed size. */
251 long explicit_packet_size
= 0;
253 /* remote_wait is normally called when the target is running and
254 waits for a stop reply packet. But sometimes we need to call it
255 when the target is already stopped. We can send a "?" packet
256 and have remote_wait read the response. Or, if we already have
257 the response, we can stash it in BUF and tell remote_wait to
258 skip calling getpkt. This flag is set when BUF contains a
259 stop reply packet and the target is not waiting. */
260 int cached_wait_status
= 0;
262 /* True, if in no ack mode. That is, neither GDB nor the stub will
263 expect acks from each other. The connection is assumed to be
265 bool noack_mode
= false;
267 /* True if we're connected in extended remote mode. */
268 bool extended
= false;
270 /* True if we resumed the target and we're waiting for the target to
271 stop. In the mean time, we can't start another command/query.
272 The remote server wouldn't be ready to process it, so we'd
273 timeout waiting for a reply that would never come and eventually
274 we'd close the connection. This can happen in asynchronous mode
275 because we allow GDB commands while the target is running. */
276 bool waiting_for_stop_reply
= false;
278 /* The status of the stub support for the various vCont actions. */
279 vCont_action_support supports_vCont
;
281 /* True if the user has pressed Ctrl-C, but the target hasn't
282 responded to that. */
283 bool ctrlc_pending_p
= false;
285 /* True if we saw a Ctrl-C while reading or writing from/to the
286 remote descriptor. At that point it is not safe to send a remote
287 interrupt packet, so we instead remember we saw the Ctrl-C and
288 process it once we're done with sending/receiving the current
289 packet, which should be shortly. If however that takes too long,
290 and the user presses Ctrl-C again, we offer to disconnect. */
291 bool got_ctrlc_during_io
= false;
293 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
294 remote_open knows that we don't have a file open when the program
296 struct serial
*remote_desc
= nullptr;
298 /* These are the threads which we last sent to the remote system. The
299 TID member will be -1 for all or -2 for not sent yet. */
300 ptid_t general_thread
= null_ptid
;
301 ptid_t continue_thread
= null_ptid
;
303 /* This is the traceframe which we last selected on the remote system.
304 It will be -1 if no traceframe is selected. */
305 int remote_traceframe_number
= -1;
307 char *last_pass_packet
= nullptr;
309 /* The last QProgramSignals packet sent to the target. We bypass
310 sending a new program signals list down to the target if the new
311 packet is exactly the same as the last we sent. IOW, we only let
312 the target know about program signals list changes. */
313 char *last_program_signals_packet
= nullptr;
315 gdb_signal last_sent_signal
= GDB_SIGNAL_0
;
317 bool last_sent_step
= false;
319 /* The execution direction of the last resume we got. */
320 exec_direction_kind last_resume_exec_dir
= EXEC_FORWARD
;
322 char *finished_object
= nullptr;
323 char *finished_annex
= nullptr;
324 ULONGEST finished_offset
= 0;
326 /* Should we try the 'ThreadInfo' query packet?
328 This variable (NOT available to the user: auto-detect only!)
329 determines whether GDB will use the new, simpler "ThreadInfo"
330 query or the older, more complex syntax for thread queries.
331 This is an auto-detect variable (set to true at each connect,
332 and set to false when the target fails to recognize it). */
333 bool use_threadinfo_query
= false;
334 bool use_threadextra_query
= false;
336 threadref echo_nextthread
{};
337 threadref nextthread
{};
338 threadref resultthreadlist
[MAXTHREADLISTRESULTS
] {};
340 /* The state of remote notification. */
341 struct remote_notif_state
*notif_state
= nullptr;
343 /* The branch trace configuration. */
344 struct btrace_config btrace_config
{};
346 /* The argument to the last "vFile:setfs:" packet we sent, used
347 to avoid sending repeated unnecessary "vFile:setfs:" packets.
348 Initialized to -1 to indicate that no "vFile:setfs:" packet
349 has yet been sent. */
352 /* A readahead cache for vFile:pread. Often, reading a binary
353 involves a sequence of small reads. E.g., when parsing an ELF
354 file. A readahead cache helps mostly the case of remote
355 debugging on a connection with higher latency, due to the
356 request/reply nature of the RSP. We only cache data for a single
357 file descriptor at a time. */
358 struct readahead_cache readahead_cache
;
360 /* The list of already fetched and acknowledged stop events. This
361 queue is used for notification Stop, and other notifications
362 don't need queue for their events, because the notification
363 events of Stop can't be consumed immediately, so that events
364 should be queued first, and be consumed by remote_wait_{ns,as}
365 one per time. Other notifications can consume their events
366 immediately, so queue is not needed for them. */
367 std::vector
<stop_reply_up
> stop_reply_queue
;
369 /* Asynchronous signal handle registered as event loop source for
370 when we have pending events ready to be passed to the core. */
371 struct async_event_handler
*remote_async_inferior_event_token
= nullptr;
373 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
374 ``forever'' still use the normal timeout mechanism. This is
375 currently used by the ASYNC code to guarentee that target reads
376 during the initial connect always time-out. Once getpkt has been
377 modified to return a timeout indication and, in turn
378 remote_wait()/wait_for_inferior() have gained a timeout parameter
380 int wait_forever_enabled_p
= 1;
383 /* Mapping of remote protocol data for each gdbarch. Usually there
384 is only one entry here, though we may see more with stubs that
385 support multi-process. */
386 std::unordered_map
<struct gdbarch
*, remote_arch_state
>
390 static const target_info remote_target_info
= {
392 N_("Remote serial target in gdb-specific protocol"),
396 class remote_target
: public process_stratum_target
399 remote_target () = default;
400 ~remote_target () override
;
402 const target_info
&info () const override
403 { return remote_target_info
; }
405 thread_control_capabilities
get_thread_control_capabilities () override
406 { return tc_schedlock
; }
408 /* Open a remote connection. */
409 static void open (const char *, int);
411 void close () override
;
413 void detach (inferior
*, int) override
;
414 void disconnect (const char *, int) override
;
416 void commit_resume () override
;
417 void resume (ptid_t
, int, enum gdb_signal
) override
;
418 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
420 void fetch_registers (struct regcache
*, int) override
;
421 void store_registers (struct regcache
*, int) override
;
422 void prepare_to_store (struct regcache
*) override
;
424 void files_info () override
;
426 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
428 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
429 enum remove_bp_reason
) override
;
432 bool stopped_by_sw_breakpoint () override
;
433 bool supports_stopped_by_sw_breakpoint () override
;
435 bool stopped_by_hw_breakpoint () override
;
437 bool supports_stopped_by_hw_breakpoint () override
;
439 bool stopped_by_watchpoint () override
;
441 bool stopped_data_address (CORE_ADDR
*) override
;
443 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
445 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
447 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
449 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
451 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
453 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
454 struct expression
*) override
;
456 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
457 struct expression
*) override
;
459 void kill () override
;
461 void load (const char *, int) override
;
463 void mourn_inferior () override
;
465 void pass_signals (gdb::array_view
<const unsigned char>) override
;
467 int set_syscall_catchpoint (int, bool, int,
468 gdb::array_view
<const int>) override
;
470 void program_signals (gdb::array_view
<const unsigned char>) override
;
472 bool thread_alive (ptid_t ptid
) override
;
474 const char *thread_name (struct thread_info
*) override
;
476 void update_thread_list () override
;
478 std::string
pid_to_str (ptid_t
) override
;
480 const char *extra_thread_info (struct thread_info
*) override
;
482 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
484 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
486 inferior
*inf
) override
;
488 void stop (ptid_t
) override
;
490 void interrupt () override
;
492 void pass_ctrlc () override
;
494 enum target_xfer_status
xfer_partial (enum target_object object
,
497 const gdb_byte
*writebuf
,
498 ULONGEST offset
, ULONGEST len
,
499 ULONGEST
*xfered_len
) override
;
501 ULONGEST
get_memory_xfer_limit () override
;
503 void rcmd (const char *command
, struct ui_file
*output
) override
;
505 char *pid_to_exec_file (int pid
) override
;
507 void log_command (const char *cmd
) override
509 serial_log_command (this, cmd
);
512 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
513 CORE_ADDR load_module_addr
,
514 CORE_ADDR offset
) override
;
516 bool can_execute_reverse () override
;
518 std::vector
<mem_region
> memory_map () override
;
520 void flash_erase (ULONGEST address
, LONGEST length
) override
;
522 void flash_done () override
;
524 const struct target_desc
*read_description () override
;
526 int search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
527 const gdb_byte
*pattern
, ULONGEST pattern_len
,
528 CORE_ADDR
*found_addrp
) override
;
530 bool can_async_p () override
;
532 bool is_async_p () override
;
534 void async (int) override
;
536 void thread_events (int) override
;
538 int can_do_single_step () override
;
540 void terminal_inferior () override
;
542 void terminal_ours () override
;
544 bool supports_non_stop () override
;
546 bool supports_multi_process () override
;
548 bool supports_disable_randomization () override
;
550 bool filesystem_is_local () override
;
553 int fileio_open (struct inferior
*inf
, const char *filename
,
554 int flags
, int mode
, int warn_if_slow
,
555 int *target_errno
) override
;
557 int fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
558 ULONGEST offset
, int *target_errno
) override
;
560 int fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
561 ULONGEST offset
, int *target_errno
) override
;
563 int fileio_fstat (int fd
, struct stat
*sb
, int *target_errno
) override
;
565 int fileio_close (int fd
, int *target_errno
) override
;
567 int fileio_unlink (struct inferior
*inf
,
568 const char *filename
,
569 int *target_errno
) override
;
571 gdb::optional
<std::string
>
572 fileio_readlink (struct inferior
*inf
,
573 const char *filename
,
574 int *target_errno
) override
;
576 bool supports_enable_disable_tracepoint () override
;
578 bool supports_string_tracing () override
;
580 bool supports_evaluation_of_breakpoint_conditions () override
;
582 bool can_run_breakpoint_commands () override
;
584 void trace_init () override
;
586 void download_tracepoint (struct bp_location
*location
) override
;
588 bool can_download_tracepoint () override
;
590 void download_trace_state_variable (const trace_state_variable
&tsv
) override
;
592 void enable_tracepoint (struct bp_location
*location
) override
;
594 void disable_tracepoint (struct bp_location
*location
) override
;
596 void trace_set_readonly_regions () override
;
598 void trace_start () override
;
600 int get_trace_status (struct trace_status
*ts
) override
;
602 void get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
605 void trace_stop () override
;
607 int trace_find (enum trace_find_type type
, int num
,
608 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
) override
;
610 bool get_trace_state_variable_value (int tsv
, LONGEST
*val
) override
;
612 int save_trace_data (const char *filename
) override
;
614 int upload_tracepoints (struct uploaded_tp
**utpp
) override
;
616 int upload_trace_state_variables (struct uploaded_tsv
**utsvp
) override
;
618 LONGEST
get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
) override
;
620 int get_min_fast_tracepoint_insn_len () override
;
622 void set_disconnected_tracing (int val
) override
;
624 void set_circular_trace_buffer (int val
) override
;
626 void set_trace_buffer_size (LONGEST val
) override
;
628 bool set_trace_notes (const char *user
, const char *notes
,
629 const char *stopnotes
) override
;
631 int core_of_thread (ptid_t ptid
) override
;
633 int verify_memory (const gdb_byte
*data
,
634 CORE_ADDR memaddr
, ULONGEST size
) override
;
637 bool get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
) override
;
639 void set_permissions () override
;
641 bool static_tracepoint_marker_at (CORE_ADDR
,
642 struct static_tracepoint_marker
*marker
)
645 std::vector
<static_tracepoint_marker
>
646 static_tracepoint_markers_by_strid (const char *id
) override
;
648 traceframe_info_up
traceframe_info () override
;
650 bool use_agent (bool use
) override
;
651 bool can_use_agent () override
;
653 struct btrace_target_info
*enable_btrace (ptid_t ptid
,
654 const struct btrace_config
*conf
) override
;
656 void disable_btrace (struct btrace_target_info
*tinfo
) override
;
658 void teardown_btrace (struct btrace_target_info
*tinfo
) override
;
660 enum btrace_error
read_btrace (struct btrace_data
*data
,
661 struct btrace_target_info
*btinfo
,
662 enum btrace_read_type type
) override
;
664 const struct btrace_config
*btrace_conf (const struct btrace_target_info
*) override
;
665 bool augmented_libraries_svr4_read () override
;
666 int follow_fork (int, int) override
;
667 void follow_exec (struct inferior
*, char *) override
;
668 int insert_fork_catchpoint (int) override
;
669 int remove_fork_catchpoint (int) override
;
670 int insert_vfork_catchpoint (int) override
;
671 int remove_vfork_catchpoint (int) override
;
672 int insert_exec_catchpoint (int) override
;
673 int remove_exec_catchpoint (int) override
;
674 enum exec_direction_kind
execution_direction () override
;
676 public: /* Remote specific methods. */
678 void remote_download_command_source (int num
, ULONGEST addr
,
679 struct command_line
*cmds
);
681 void remote_file_put (const char *local_file
, const char *remote_file
,
683 void remote_file_get (const char *remote_file
, const char *local_file
,
685 void remote_file_delete (const char *remote_file
, int from_tty
);
687 int remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
688 ULONGEST offset
, int *remote_errno
);
689 int remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
690 ULONGEST offset
, int *remote_errno
);
691 int remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
692 ULONGEST offset
, int *remote_errno
);
694 int remote_hostio_send_command (int command_bytes
, int which_packet
,
695 int *remote_errno
, char **attachment
,
696 int *attachment_len
);
697 int remote_hostio_set_filesystem (struct inferior
*inf
,
699 /* We should get rid of this and use fileio_open directly. */
700 int remote_hostio_open (struct inferior
*inf
, const char *filename
,
701 int flags
, int mode
, int warn_if_slow
,
703 int remote_hostio_close (int fd
, int *remote_errno
);
705 int remote_hostio_unlink (inferior
*inf
, const char *filename
,
708 struct remote_state
*get_remote_state ();
710 long get_remote_packet_size (void);
711 long get_memory_packet_size (struct memory_packet_config
*config
);
713 long get_memory_write_packet_size ();
714 long get_memory_read_packet_size ();
716 char *append_pending_thread_resumptions (char *p
, char *endp
,
718 static void open_1 (const char *name
, int from_tty
, int extended_p
);
719 void start_remote (int from_tty
, int extended_p
);
720 void remote_detach_1 (struct inferior
*inf
, int from_tty
);
722 char *append_resumption (char *p
, char *endp
,
723 ptid_t ptid
, int step
, gdb_signal siggnal
);
724 int remote_resume_with_vcont (ptid_t ptid
, int step
,
727 void add_current_inferior_and_thread (char *wait_status
);
729 ptid_t
wait_ns (ptid_t ptid
, struct target_waitstatus
*status
,
731 ptid_t
wait_as (ptid_t ptid
, target_waitstatus
*status
,
734 ptid_t
process_stop_reply (struct stop_reply
*stop_reply
,
735 target_waitstatus
*status
);
737 void remote_notice_new_inferior (ptid_t currthread
, int executing
);
739 void process_initial_stop_replies (int from_tty
);
741 thread_info
*remote_add_thread (ptid_t ptid
, bool running
, bool executing
);
743 void btrace_sync_conf (const btrace_config
*conf
);
745 void remote_btrace_maybe_reopen ();
747 void remove_new_fork_children (threads_listing_context
*context
);
748 void kill_new_fork_children (int pid
);
749 void discard_pending_stop_replies (struct inferior
*inf
);
750 int stop_reply_queue_length ();
752 void check_pending_events_prevent_wildcard_vcont
753 (int *may_global_wildcard_vcont
);
755 void discard_pending_stop_replies_in_queue ();
756 struct stop_reply
*remote_notif_remove_queued_reply (ptid_t ptid
);
757 struct stop_reply
*queued_stop_reply (ptid_t ptid
);
758 int peek_stop_reply (ptid_t ptid
);
759 void remote_parse_stop_reply (const char *buf
, stop_reply
*event
);
761 void remote_stop_ns (ptid_t ptid
);
762 void remote_interrupt_as ();
763 void remote_interrupt_ns ();
765 char *remote_get_noisy_reply ();
766 int remote_query_attached (int pid
);
767 inferior
*remote_add_inferior (int fake_pid_p
, int pid
, int attached
,
770 ptid_t
remote_current_thread (ptid_t oldpid
);
771 ptid_t
get_current_thread (char *wait_status
);
773 void set_thread (ptid_t ptid
, int gen
);
774 void set_general_thread (ptid_t ptid
);
775 void set_continue_thread (ptid_t ptid
);
776 void set_general_process ();
778 char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
780 int remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
781 gdb_ext_thread_info
*info
);
782 int remote_get_threadinfo (threadref
*threadid
, int fieldset
,
783 gdb_ext_thread_info
*info
);
785 int parse_threadlist_response (char *pkt
, int result_limit
,
786 threadref
*original_echo
,
787 threadref
*resultlist
,
789 int remote_get_threadlist (int startflag
, threadref
*nextthread
,
790 int result_limit
, int *done
, int *result_count
,
791 threadref
*threadlist
);
793 int remote_threadlist_iterator (rmt_thread_action stepfunction
,
794 void *context
, int looplimit
);
796 int remote_get_threads_with_ql (threads_listing_context
*context
);
797 int remote_get_threads_with_qxfer (threads_listing_context
*context
);
798 int remote_get_threads_with_qthreadinfo (threads_listing_context
*context
);
800 void extended_remote_restart ();
804 void remote_check_symbols ();
806 void remote_supported_packet (const struct protocol_feature
*feature
,
807 enum packet_support support
,
808 const char *argument
);
810 void remote_query_supported ();
812 void remote_packet_size (const protocol_feature
*feature
,
813 packet_support support
, const char *value
);
815 void remote_serial_quit_handler ();
817 void remote_detach_pid (int pid
);
819 void remote_vcont_probe ();
821 void remote_resume_with_hc (ptid_t ptid
, int step
,
824 void send_interrupt_sequence ();
825 void interrupt_query ();
827 void remote_notif_get_pending_events (notif_client
*nc
);
829 int fetch_register_using_p (struct regcache
*regcache
,
831 int send_g_packet ();
832 void process_g_packet (struct regcache
*regcache
);
833 void fetch_registers_using_g (struct regcache
*regcache
);
834 int store_register_using_P (const struct regcache
*regcache
,
836 void store_registers_using_G (const struct regcache
*regcache
);
838 void set_remote_traceframe ();
840 void check_binary_download (CORE_ADDR addr
);
842 target_xfer_status
remote_write_bytes_aux (const char *header
,
844 const gdb_byte
*myaddr
,
847 ULONGEST
*xfered_len_units
,
851 target_xfer_status
remote_write_bytes (CORE_ADDR memaddr
,
852 const gdb_byte
*myaddr
, ULONGEST len
,
853 int unit_size
, ULONGEST
*xfered_len
);
855 target_xfer_status
remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
857 int unit_size
, ULONGEST
*xfered_len_units
);
859 target_xfer_status
remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
863 ULONGEST
*xfered_len
);
865 target_xfer_status
remote_read_bytes (CORE_ADDR memaddr
,
866 gdb_byte
*myaddr
, ULONGEST len
,
868 ULONGEST
*xfered_len
);
870 packet_result
remote_send_printf (const char *format
, ...)
871 ATTRIBUTE_PRINTF (2, 3);
873 target_xfer_status
remote_flash_write (ULONGEST address
,
874 ULONGEST length
, ULONGEST
*xfered_len
,
875 const gdb_byte
*data
);
877 int readchar (int timeout
);
879 void remote_serial_write (const char *str
, int len
);
881 int putpkt (const char *buf
);
882 int putpkt_binary (const char *buf
, int cnt
);
884 int putpkt (const gdb::char_vector
&buf
)
886 return putpkt (buf
.data ());
890 long read_frame (gdb::char_vector
*buf_p
);
891 void getpkt (gdb::char_vector
*buf
, int forever
);
892 int getpkt_or_notif_sane_1 (gdb::char_vector
*buf
, int forever
,
893 int expecting_notif
, int *is_notif
);
894 int getpkt_sane (gdb::char_vector
*buf
, int forever
);
895 int getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
897 int remote_vkill (int pid
);
898 void remote_kill_k ();
900 void extended_remote_disable_randomization (int val
);
901 int extended_remote_run (const std::string
&args
);
903 void send_environment_packet (const char *action
,
907 void extended_remote_environment_support ();
908 void extended_remote_set_inferior_cwd ();
910 target_xfer_status
remote_write_qxfer (const char *object_name
,
912 const gdb_byte
*writebuf
,
913 ULONGEST offset
, LONGEST len
,
914 ULONGEST
*xfered_len
,
915 struct packet_config
*packet
);
917 target_xfer_status
remote_read_qxfer (const char *object_name
,
919 gdb_byte
*readbuf
, ULONGEST offset
,
921 ULONGEST
*xfered_len
,
922 struct packet_config
*packet
);
924 void push_stop_reply (struct stop_reply
*new_event
);
926 bool vcont_r_supported ();
928 void packet_command (const char *args
, int from_tty
);
930 private: /* data fields */
932 /* The remote state. Don't reference this directly. Use the
933 get_remote_state method instead. */
934 remote_state m_remote_state
;
937 static const target_info extended_remote_target_info
= {
939 N_("Extended remote serial target in gdb-specific protocol"),
943 /* Set up the extended remote target by extending the standard remote
944 target and adding to it. */
946 class extended_remote_target final
: public remote_target
949 const target_info
&info () const override
950 { return extended_remote_target_info
; }
952 /* Open an extended-remote connection. */
953 static void open (const char *, int);
955 bool can_create_inferior () override
{ return true; }
956 void create_inferior (const char *, const std::string
&,
957 char **, int) override
;
959 void detach (inferior
*, int) override
;
961 bool can_attach () override
{ return true; }
962 void attach (const char *, int) override
;
964 void post_attach (int) override
;
965 bool supports_disable_randomization () override
;
968 /* Per-program-space data key. */
969 static const struct program_space_data
*remote_pspace_data
;
971 /* The variable registered as the control variable used by the
972 remote exec-file commands. While the remote exec-file setting is
973 per-program-space, the set/show machinery uses this as the
974 location of the remote exec-file value. */
975 static char *remote_exec_file_var
;
977 /* The size to align memory write packets, when practical. The protocol
978 does not guarantee any alignment, and gdb will generate short
979 writes and unaligned writes, but even as a best-effort attempt this
980 can improve bulk transfers. For instance, if a write is misaligned
981 relative to the target's data bus, the stub may need to make an extra
982 round trip fetching data from the target. This doesn't make a
983 huge difference, but it's easy to do, so we try to be helpful.
985 The alignment chosen is arbitrary; usually data bus width is
986 important here, not the possibly larger cache line size. */
987 enum { REMOTE_ALIGN_WRITES
= 16 };
989 /* Prototypes for local functions. */
991 static int hexnumlen (ULONGEST num
);
993 static int stubhex (int ch
);
995 static int hexnumstr (char *, ULONGEST
);
997 static int hexnumnstr (char *, ULONGEST
, int);
999 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
1001 static void print_packet (const char *);
1003 static int stub_unpack_int (char *buff
, int fieldlength
);
1005 struct packet_config
;
1007 static void show_packet_config_cmd (struct packet_config
*config
);
1009 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
1011 struct cmd_list_element
*c
,
1014 static ptid_t
read_ptid (const char *buf
, const char **obuf
);
1016 static void remote_async_inferior_event_handler (gdb_client_data
);
1018 static bool remote_read_description_p (struct target_ops
*target
);
1020 static void remote_console_output (const char *msg
);
1022 static void remote_btrace_reset (remote_state
*rs
);
1024 static void remote_unpush_and_throw (void);
1028 static struct cmd_list_element
*remote_cmdlist
;
1030 /* For "set remote" and "show remote". */
1032 static struct cmd_list_element
*remote_set_cmdlist
;
1033 static struct cmd_list_element
*remote_show_cmdlist
;
1035 /* Controls whether GDB is willing to use range stepping. */
1037 static int use_range_stepping
= 1;
1039 /* The max number of chars in debug output. The rest of chars are
1042 #define REMOTE_DEBUG_MAX_CHAR 512
1044 /* Private data that we'll store in (struct thread_info)->priv. */
1045 struct remote_thread_info
: public private_thread_info
1051 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1052 sequence of bytes. */
1053 gdb::byte_vector thread_handle
;
1055 /* Whether the target stopped for a breakpoint/watchpoint. */
1056 enum target_stop_reason stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
1058 /* This is set to the data address of the access causing the target
1059 to stop for a watchpoint. */
1060 CORE_ADDR watch_data_address
= 0;
1062 /* Fields used by the vCont action coalescing implemented in
1063 remote_resume / remote_commit_resume. remote_resume stores each
1064 thread's last resume request in these fields, so that a later
1065 remote_commit_resume knows which is the proper action for this
1066 thread to include in the vCont packet. */
1068 /* True if the last target_resume call for this thread was a step
1069 request, false if a continue request. */
1070 int last_resume_step
= 0;
1072 /* The signal specified in the last target_resume call for this
1074 gdb_signal last_resume_sig
= GDB_SIGNAL_0
;
1076 /* Whether this thread was already vCont-resumed on the remote
1078 int vcont_resumed
= 0;
1081 remote_state::remote_state ()
1086 remote_state::~remote_state ()
1088 xfree (this->last_pass_packet
);
1089 xfree (this->last_program_signals_packet
);
1090 xfree (this->finished_object
);
1091 xfree (this->finished_annex
);
1094 /* Utility: generate error from an incoming stub packet. */
1096 trace_error (char *buf
)
1099 return; /* not an error msg */
1102 case '1': /* malformed packet error */
1103 if (*++buf
== '0') /* general case: */
1104 error (_("remote.c: error in outgoing packet."));
1106 error (_("remote.c: error in outgoing packet at field #%ld."),
1107 strtol (buf
, NULL
, 16));
1109 error (_("Target returns error code '%s'."), buf
);
1113 /* Utility: wait for reply from stub, while accepting "O" packets. */
1116 remote_target::remote_get_noisy_reply ()
1118 struct remote_state
*rs
= get_remote_state ();
1120 do /* Loop on reply from remote stub. */
1124 QUIT
; /* Allow user to bail out with ^C. */
1125 getpkt (&rs
->buf
, 0);
1126 buf
= rs
->buf
.data ();
1129 else if (startswith (buf
, "qRelocInsn:"))
1132 CORE_ADDR from
, to
, org_to
;
1134 int adjusted_size
= 0;
1137 p
= buf
+ strlen ("qRelocInsn:");
1138 pp
= unpack_varlen_hex (p
, &ul
);
1140 error (_("invalid qRelocInsn packet: %s"), buf
);
1144 unpack_varlen_hex (p
, &ul
);
1151 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
1154 catch (const gdb_exception
&ex
)
1156 if (ex
.error
== MEMORY_ERROR
)
1158 /* Propagate memory errors silently back to the
1159 target. The stub may have limited the range of
1160 addresses we can write to, for example. */
1164 /* Something unexpectedly bad happened. Be verbose
1165 so we can tell what, and propagate the error back
1166 to the stub, so it doesn't get stuck waiting for
1168 exception_fprintf (gdb_stderr
, ex
,
1169 _("warning: relocating instruction: "));
1176 adjusted_size
= to
- org_to
;
1178 xsnprintf (buf
, rs
->buf
.size (), "qRelocInsn:%x", adjusted_size
);
1182 else if (buf
[0] == 'O' && buf
[1] != 'K')
1183 remote_console_output (buf
+ 1); /* 'O' message from stub */
1185 return buf
; /* Here's the actual reply. */
1190 struct remote_arch_state
*
1191 remote_state::get_remote_arch_state (struct gdbarch
*gdbarch
)
1193 remote_arch_state
*rsa
;
1195 auto it
= this->m_arch_states
.find (gdbarch
);
1196 if (it
== this->m_arch_states
.end ())
1198 auto p
= this->m_arch_states
.emplace (std::piecewise_construct
,
1199 std::forward_as_tuple (gdbarch
),
1200 std::forward_as_tuple (gdbarch
));
1201 rsa
= &p
.first
->second
;
1203 /* Make sure that the packet buffer is plenty big enough for
1204 this architecture. */
1205 if (this->buf
.size () < rsa
->remote_packet_size
)
1206 this->buf
.resize (2 * rsa
->remote_packet_size
);
1214 /* Fetch the global remote target state. */
1217 remote_target::get_remote_state ()
1219 /* Make sure that the remote architecture state has been
1220 initialized, because doing so might reallocate rs->buf. Any
1221 function which calls getpkt also needs to be mindful of changes
1222 to rs->buf, but this call limits the number of places which run
1224 m_remote_state
.get_remote_arch_state (target_gdbarch ());
1226 return &m_remote_state
;
1229 /* Cleanup routine for the remote module's pspace data. */
1232 remote_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
1234 char *remote_exec_file
= (char *) arg
;
1236 xfree (remote_exec_file
);
1239 /* Fetch the remote exec-file from the current program space. */
1242 get_remote_exec_file (void)
1244 char *remote_exec_file
;
1247 = (char *) program_space_data (current_program_space
,
1248 remote_pspace_data
);
1249 if (remote_exec_file
== NULL
)
1252 return remote_exec_file
;
1255 /* Set the remote exec file for PSPACE. */
1258 set_pspace_remote_exec_file (struct program_space
*pspace
,
1259 char *remote_exec_file
)
1261 char *old_file
= (char *) program_space_data (pspace
, remote_pspace_data
);
1264 set_program_space_data (pspace
, remote_pspace_data
,
1265 xstrdup (remote_exec_file
));
1268 /* The "set/show remote exec-file" set command hook. */
1271 set_remote_exec_file (const char *ignored
, int from_tty
,
1272 struct cmd_list_element
*c
)
1274 gdb_assert (remote_exec_file_var
!= NULL
);
1275 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
1278 /* The "set/show remote exec-file" show command hook. */
1281 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
1282 struct cmd_list_element
*cmd
, const char *value
)
1284 fprintf_filtered (file
, "%s\n", remote_exec_file_var
);
1288 compare_pnums (const void *lhs_
, const void *rhs_
)
1290 const struct packet_reg
* const *lhs
1291 = (const struct packet_reg
* const *) lhs_
;
1292 const struct packet_reg
* const *rhs
1293 = (const struct packet_reg
* const *) rhs_
;
1295 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
1297 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
1304 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
1306 int regnum
, num_remote_regs
, offset
;
1307 struct packet_reg
**remote_regs
;
1309 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1311 struct packet_reg
*r
= ®s
[regnum
];
1313 if (register_size (gdbarch
, regnum
) == 0)
1314 /* Do not try to fetch zero-sized (placeholder) registers. */
1317 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
1322 /* Define the g/G packet format as the contents of each register
1323 with a remote protocol number, in order of ascending protocol
1326 remote_regs
= XALLOCAVEC (struct packet_reg
*, gdbarch_num_regs (gdbarch
));
1327 for (num_remote_regs
= 0, regnum
= 0;
1328 regnum
< gdbarch_num_regs (gdbarch
);
1330 if (regs
[regnum
].pnum
!= -1)
1331 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
1333 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
1336 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
1338 remote_regs
[regnum
]->in_g_packet
= 1;
1339 remote_regs
[regnum
]->offset
= offset
;
1340 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
1346 /* Given the architecture described by GDBARCH, return the remote
1347 protocol register's number and the register's offset in the g/G
1348 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1349 If the target does not have a mapping for REGNUM, return false,
1350 otherwise, return true. */
1353 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
1354 int *pnum
, int *poffset
)
1356 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
1358 std::vector
<packet_reg
> regs (gdbarch_num_regs (gdbarch
));
1360 map_regcache_remote_table (gdbarch
, regs
.data ());
1362 *pnum
= regs
[regnum
].pnum
;
1363 *poffset
= regs
[regnum
].offset
;
1368 remote_arch_state::remote_arch_state (struct gdbarch
*gdbarch
)
1370 /* Use the architecture to build a regnum<->pnum table, which will be
1371 1:1 unless a feature set specifies otherwise. */
1372 this->regs
.reset (new packet_reg
[gdbarch_num_regs (gdbarch
)] ());
1374 /* Record the maximum possible size of the g packet - it may turn out
1376 this->sizeof_g_packet
1377 = map_regcache_remote_table (gdbarch
, this->regs
.get ());
1379 /* Default maximum number of characters in a packet body. Many
1380 remote stubs have a hardwired buffer size of 400 bytes
1381 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
1382 as the maximum packet-size to ensure that the packet and an extra
1383 NUL character can always fit in the buffer. This stops GDB
1384 trashing stubs that try to squeeze an extra NUL into what is
1385 already a full buffer (As of 1999-12-04 that was most stubs). */
1386 this->remote_packet_size
= 400 - 1;
1388 /* This one is filled in when a ``g'' packet is received. */
1389 this->actual_register_packet_size
= 0;
1391 /* Should rsa->sizeof_g_packet needs more space than the
1392 default, adjust the size accordingly. Remember that each byte is
1393 encoded as two characters. 32 is the overhead for the packet
1394 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
1395 (``$NN:G...#NN'') is a better guess, the below has been padded a
1397 if (this->sizeof_g_packet
> ((this->remote_packet_size
- 32) / 2))
1398 this->remote_packet_size
= (this->sizeof_g_packet
* 2 + 32);
1401 /* Get a pointer to the current remote target. If not connected to a
1402 remote target, return NULL. */
1404 static remote_target
*
1405 get_current_remote_target ()
1407 target_ops
*proc_target
= find_target_at (process_stratum
);
1408 return dynamic_cast<remote_target
*> (proc_target
);
1411 /* Return the current allowed size of a remote packet. This is
1412 inferred from the current architecture, and should be used to
1413 limit the length of outgoing packets. */
1415 remote_target::get_remote_packet_size ()
1417 struct remote_state
*rs
= get_remote_state ();
1418 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1420 if (rs
->explicit_packet_size
)
1421 return rs
->explicit_packet_size
;
1423 return rsa
->remote_packet_size
;
1426 static struct packet_reg
*
1427 packet_reg_from_regnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1430 if (regnum
< 0 && regnum
>= gdbarch_num_regs (gdbarch
))
1434 struct packet_reg
*r
= &rsa
->regs
[regnum
];
1436 gdb_assert (r
->regnum
== regnum
);
1441 static struct packet_reg
*
1442 packet_reg_from_pnum (struct gdbarch
*gdbarch
, struct remote_arch_state
*rsa
,
1447 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1449 struct packet_reg
*r
= &rsa
->regs
[i
];
1451 if (r
->pnum
== pnum
)
1457 /* Allow the user to specify what sequence to send to the remote
1458 when he requests a program interruption: Although ^C is usually
1459 what remote systems expect (this is the default, here), it is
1460 sometimes preferable to send a break. On other systems such
1461 as the Linux kernel, a break followed by g, which is Magic SysRq g
1462 is required in order to interrupt the execution. */
1463 const char interrupt_sequence_control_c
[] = "Ctrl-C";
1464 const char interrupt_sequence_break
[] = "BREAK";
1465 const char interrupt_sequence_break_g
[] = "BREAK-g";
1466 static const char *const interrupt_sequence_modes
[] =
1468 interrupt_sequence_control_c
,
1469 interrupt_sequence_break
,
1470 interrupt_sequence_break_g
,
1473 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
1476 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
1477 struct cmd_list_element
*c
,
1480 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
1481 fprintf_filtered (file
,
1482 _("Send the ASCII ETX character (Ctrl-c) "
1483 "to the remote target to interrupt the "
1484 "execution of the program.\n"));
1485 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
1486 fprintf_filtered (file
,
1487 _("send a break signal to the remote target "
1488 "to interrupt the execution of the program.\n"));
1489 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
1490 fprintf_filtered (file
,
1491 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1492 "the remote target to interrupt the execution "
1493 "of Linux kernel.\n"));
1495 internal_error (__FILE__
, __LINE__
,
1496 _("Invalid value for interrupt_sequence_mode: %s."),
1497 interrupt_sequence_mode
);
1500 /* This boolean variable specifies whether interrupt_sequence is sent
1501 to the remote target when gdb connects to it.
1502 This is mostly needed when you debug the Linux kernel: The Linux kernel
1503 expects BREAK g which is Magic SysRq g for connecting gdb. */
1504 static int interrupt_on_connect
= 0;
1506 /* This variable is used to implement the "set/show remotebreak" commands.
1507 Since these commands are now deprecated in favor of "set/show remote
1508 interrupt-sequence", it no longer has any effect on the code. */
1509 static int remote_break
;
1512 set_remotebreak (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1515 interrupt_sequence_mode
= interrupt_sequence_break
;
1517 interrupt_sequence_mode
= interrupt_sequence_control_c
;
1521 show_remotebreak (struct ui_file
*file
, int from_tty
,
1522 struct cmd_list_element
*c
,
1527 /* This variable sets the number of bits in an address that are to be
1528 sent in a memory ("M" or "m") packet. Normally, after stripping
1529 leading zeros, the entire address would be sent. This variable
1530 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1531 initial implementation of remote.c restricted the address sent in
1532 memory packets to ``host::sizeof long'' bytes - (typically 32
1533 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1534 address was never sent. Since fixing this bug may cause a break in
1535 some remote targets this variable is principly provided to
1536 facilitate backward compatibility. */
1538 static unsigned int remote_address_size
;
1541 /* User configurable variables for the number of characters in a
1542 memory read/write packet. MIN (rsa->remote_packet_size,
1543 rsa->sizeof_g_packet) is the default. Some targets need smaller
1544 values (fifo overruns, et.al.) and some users need larger values
1545 (speed up transfers). The variables ``preferred_*'' (the user
1546 request), ``current_*'' (what was actually set) and ``forced_*''
1547 (Positive - a soft limit, negative - a hard limit). */
1549 struct memory_packet_config
1556 /* The default max memory-write-packet-size, when the setting is
1557 "fixed". The 16k is historical. (It came from older GDB's using
1558 alloca for buffers and the knowledge (folklore?) that some hosts
1559 don't cope very well with large alloca calls.) */
1560 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1562 /* The minimum remote packet size for memory transfers. Ensures we
1563 can write at least one byte. */
1564 #define MIN_MEMORY_PACKET_SIZE 20
1566 /* Get the memory packet size, assuming it is fixed. */
1569 get_fixed_memory_packet_size (struct memory_packet_config
*config
)
1571 gdb_assert (config
->fixed_p
);
1573 if (config
->size
<= 0)
1574 return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
;
1576 return config
->size
;
1579 /* Compute the current size of a read/write packet. Since this makes
1580 use of ``actual_register_packet_size'' the computation is dynamic. */
1583 remote_target::get_memory_packet_size (struct memory_packet_config
*config
)
1585 struct remote_state
*rs
= get_remote_state ();
1586 remote_arch_state
*rsa
= rs
->get_remote_arch_state (target_gdbarch ());
1589 if (config
->fixed_p
)
1590 what_they_get
= get_fixed_memory_packet_size (config
);
1593 what_they_get
= get_remote_packet_size ();
1594 /* Limit the packet to the size specified by the user. */
1595 if (config
->size
> 0
1596 && what_they_get
> config
->size
)
1597 what_they_get
= config
->size
;
1599 /* Limit it to the size of the targets ``g'' response unless we have
1600 permission from the stub to use a larger packet size. */
1601 if (rs
->explicit_packet_size
== 0
1602 && rsa
->actual_register_packet_size
> 0
1603 && what_they_get
> rsa
->actual_register_packet_size
)
1604 what_they_get
= rsa
->actual_register_packet_size
;
1606 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1607 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1609 /* Make sure there is room in the global buffer for this packet
1610 (including its trailing NUL byte). */
1611 if (rs
->buf
.size () < what_they_get
+ 1)
1612 rs
->buf
.resize (2 * what_they_get
);
1614 return what_they_get
;
1617 /* Update the size of a read/write packet. If they user wants
1618 something really big then do a sanity check. */
1621 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1623 int fixed_p
= config
->fixed_p
;
1624 long size
= config
->size
;
1627 error (_("Argument required (integer, `fixed' or `limited')."));
1628 else if (strcmp (args
, "hard") == 0
1629 || strcmp (args
, "fixed") == 0)
1631 else if (strcmp (args
, "soft") == 0
1632 || strcmp (args
, "limit") == 0)
1638 size
= strtoul (args
, &end
, 0);
1640 error (_("Invalid %s (bad syntax)."), config
->name
);
1642 /* Instead of explicitly capping the size of a packet to or
1643 disallowing it, the user is allowed to set the size to
1644 something arbitrarily large. */
1648 if (fixed_p
&& !config
->fixed_p
)
1650 /* So that the query shows the correct value. */
1651 long query_size
= (size
<= 0
1652 ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1655 if (! query (_("The target may not be able to correctly handle a %s\n"
1656 "of %ld bytes. Change the packet size? "),
1657 config
->name
, query_size
))
1658 error (_("Packet size not changed."));
1660 /* Update the config. */
1661 config
->fixed_p
= fixed_p
;
1662 config
->size
= size
;
1666 show_memory_packet_size (struct memory_packet_config
*config
)
1668 if (config
->size
== 0)
1669 printf_filtered (_("The %s is 0 (default). "), config
->name
);
1671 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1672 if (config
->fixed_p
)
1673 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1674 get_fixed_memory_packet_size (config
));
1677 remote_target
*remote
= get_current_remote_target ();
1680 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1681 remote
->get_memory_packet_size (config
));
1683 puts_filtered ("The actual limit will be further reduced "
1684 "dependent on the target.\n");
1688 static struct memory_packet_config memory_write_packet_config
=
1690 "memory-write-packet-size",
1694 set_memory_write_packet_size (const char *args
, int from_tty
)
1696 set_memory_packet_size (args
, &memory_write_packet_config
);
1700 show_memory_write_packet_size (const char *args
, int from_tty
)
1702 show_memory_packet_size (&memory_write_packet_config
);
1705 /* Show the number of hardware watchpoints that can be used. */
1708 show_hardware_watchpoint_limit (struct ui_file
*file
, int from_tty
,
1709 struct cmd_list_element
*c
,
1712 fprintf_filtered (file
, _("The maximum number of target hardware "
1713 "watchpoints is %s.\n"), value
);
1716 /* Show the length limit (in bytes) for hardware watchpoints. */
1719 show_hardware_watchpoint_length_limit (struct ui_file
*file
, int from_tty
,
1720 struct cmd_list_element
*c
,
1723 fprintf_filtered (file
, _("The maximum length (in bytes) of a target "
1724 "hardware watchpoint is %s.\n"), value
);
1727 /* Show the number of hardware breakpoints that can be used. */
1730 show_hardware_breakpoint_limit (struct ui_file
*file
, int from_tty
,
1731 struct cmd_list_element
*c
,
1734 fprintf_filtered (file
, _("The maximum number of target hardware "
1735 "breakpoints is %s.\n"), value
);
1739 remote_target::get_memory_write_packet_size ()
1741 return get_memory_packet_size (&memory_write_packet_config
);
1744 static struct memory_packet_config memory_read_packet_config
=
1746 "memory-read-packet-size",
1750 set_memory_read_packet_size (const char *args
, int from_tty
)
1752 set_memory_packet_size (args
, &memory_read_packet_config
);
1756 show_memory_read_packet_size (const char *args
, int from_tty
)
1758 show_memory_packet_size (&memory_read_packet_config
);
1762 remote_target::get_memory_read_packet_size ()
1764 long size
= get_memory_packet_size (&memory_read_packet_config
);
1766 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1767 extra buffer size argument before the memory read size can be
1768 increased beyond this. */
1769 if (size
> get_remote_packet_size ())
1770 size
= get_remote_packet_size ();
1776 struct packet_config
1781 /* If auto, GDB auto-detects support for this packet or feature,
1782 either through qSupported, or by trying the packet and looking
1783 at the response. If true, GDB assumes the target supports this
1784 packet. If false, the packet is disabled. Configs that don't
1785 have an associated command always have this set to auto. */
1786 enum auto_boolean detect
;
1788 /* Does the target support this packet? */
1789 enum packet_support support
;
1792 static enum packet_support
packet_config_support (struct packet_config
*config
);
1793 static enum packet_support
packet_support (int packet
);
1796 show_packet_config_cmd (struct packet_config
*config
)
1798 const char *support
= "internal-error";
1800 switch (packet_config_support (config
))
1803 support
= "enabled";
1805 case PACKET_DISABLE
:
1806 support
= "disabled";
1808 case PACKET_SUPPORT_UNKNOWN
:
1809 support
= "unknown";
1812 switch (config
->detect
)
1814 case AUTO_BOOLEAN_AUTO
:
1815 printf_filtered (_("Support for the `%s' packet "
1816 "is auto-detected, currently %s.\n"),
1817 config
->name
, support
);
1819 case AUTO_BOOLEAN_TRUE
:
1820 case AUTO_BOOLEAN_FALSE
:
1821 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1822 config
->name
, support
);
1828 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1829 const char *title
, int legacy
)
1835 config
->name
= name
;
1836 config
->title
= title
;
1837 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1839 show_doc
= xstrprintf ("Show current use of remote "
1840 "protocol `%s' (%s) packet",
1842 /* set/show TITLE-packet {auto,on,off} */
1843 cmd_name
= xstrprintf ("%s-packet", title
);
1844 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1845 &config
->detect
, set_doc
,
1846 show_doc
, NULL
, /* help_doc */
1848 show_remote_protocol_packet_cmd
,
1849 &remote_set_cmdlist
, &remote_show_cmdlist
);
1850 /* The command code copies the documentation strings. */
1853 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1858 legacy_name
= xstrprintf ("%s-packet", name
);
1859 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1860 &remote_set_cmdlist
);
1861 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1862 &remote_show_cmdlist
);
1866 static enum packet_result
1867 packet_check_result (const char *buf
)
1871 /* The stub recognized the packet request. Check that the
1872 operation succeeded. */
1874 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1876 /* "Enn" - definitly an error. */
1877 return PACKET_ERROR
;
1879 /* Always treat "E." as an error. This will be used for
1880 more verbose error messages, such as E.memtypes. */
1881 if (buf
[0] == 'E' && buf
[1] == '.')
1882 return PACKET_ERROR
;
1884 /* The packet may or may not be OK. Just assume it is. */
1888 /* The stub does not support the packet. */
1889 return PACKET_UNKNOWN
;
1892 static enum packet_result
1893 packet_check_result (const gdb::char_vector
&buf
)
1895 return packet_check_result (buf
.data ());
1898 static enum packet_result
1899 packet_ok (const char *buf
, struct packet_config
*config
)
1901 enum packet_result result
;
1903 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1904 && config
->support
== PACKET_DISABLE
)
1905 internal_error (__FILE__
, __LINE__
,
1906 _("packet_ok: attempt to use a disabled packet"));
1908 result
= packet_check_result (buf
);
1913 /* The stub recognized the packet request. */
1914 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1917 fprintf_unfiltered (gdb_stdlog
,
1918 "Packet %s (%s) is supported\n",
1919 config
->name
, config
->title
);
1920 config
->support
= PACKET_ENABLE
;
1923 case PACKET_UNKNOWN
:
1924 /* The stub does not support the packet. */
1925 if (config
->detect
== AUTO_BOOLEAN_AUTO
1926 && config
->support
== PACKET_ENABLE
)
1928 /* If the stub previously indicated that the packet was
1929 supported then there is a protocol error. */
1930 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1931 config
->name
, config
->title
);
1933 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1935 /* The user set it wrong. */
1936 error (_("Enabled packet %s (%s) not recognized by stub"),
1937 config
->name
, config
->title
);
1941 fprintf_unfiltered (gdb_stdlog
,
1942 "Packet %s (%s) is NOT supported\n",
1943 config
->name
, config
->title
);
1944 config
->support
= PACKET_DISABLE
;
1951 static enum packet_result
1952 packet_ok (const gdb::char_vector
&buf
, struct packet_config
*config
)
1954 return packet_ok (buf
.data (), config
);
1971 PACKET_vFile_pwrite
,
1973 PACKET_vFile_unlink
,
1974 PACKET_vFile_readlink
,
1977 PACKET_qXfer_features
,
1978 PACKET_qXfer_exec_file
,
1979 PACKET_qXfer_libraries
,
1980 PACKET_qXfer_libraries_svr4
,
1981 PACKET_qXfer_memory_map
,
1982 PACKET_qXfer_spu_read
,
1983 PACKET_qXfer_spu_write
,
1984 PACKET_qXfer_osdata
,
1985 PACKET_qXfer_threads
,
1986 PACKET_qXfer_statictrace_read
,
1987 PACKET_qXfer_traceframe_info
,
1993 PACKET_QPassSignals
,
1994 PACKET_QCatchSyscalls
,
1995 PACKET_QProgramSignals
,
1996 PACKET_QSetWorkingDir
,
1997 PACKET_QStartupWithShell
,
1998 PACKET_QEnvironmentHexEncoded
,
1999 PACKET_QEnvironmentReset
,
2000 PACKET_QEnvironmentUnset
,
2002 PACKET_qSearch_memory
,
2005 PACKET_QStartNoAckMode
,
2007 PACKET_qXfer_siginfo_read
,
2008 PACKET_qXfer_siginfo_write
,
2011 /* Support for conditional tracepoints. */
2012 PACKET_ConditionalTracepoints
,
2014 /* Support for target-side breakpoint conditions. */
2015 PACKET_ConditionalBreakpoints
,
2017 /* Support for target-side breakpoint commands. */
2018 PACKET_BreakpointCommands
,
2020 /* Support for fast tracepoints. */
2021 PACKET_FastTracepoints
,
2023 /* Support for static tracepoints. */
2024 PACKET_StaticTracepoints
,
2026 /* Support for installing tracepoints while a trace experiment is
2028 PACKET_InstallInTrace
,
2032 PACKET_TracepointSource
,
2035 PACKET_QDisableRandomization
,
2037 PACKET_QTBuffer_size
,
2041 PACKET_qXfer_btrace
,
2043 /* Support for the QNonStop packet. */
2046 /* Support for the QThreadEvents packet. */
2047 PACKET_QThreadEvents
,
2049 /* Support for multi-process extensions. */
2050 PACKET_multiprocess_feature
,
2052 /* Support for enabling and disabling tracepoints while a trace
2053 experiment is running. */
2054 PACKET_EnableDisableTracepoints_feature
,
2056 /* Support for collecting strings using the tracenz bytecode. */
2057 PACKET_tracenz_feature
,
2059 /* Support for continuing to run a trace experiment while GDB is
2061 PACKET_DisconnectedTracing_feature
,
2063 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
2064 PACKET_augmented_libraries_svr4_read_feature
,
2066 /* Support for the qXfer:btrace-conf:read packet. */
2067 PACKET_qXfer_btrace_conf
,
2069 /* Support for the Qbtrace-conf:bts:size packet. */
2070 PACKET_Qbtrace_conf_bts_size
,
2072 /* Support for swbreak+ feature. */
2073 PACKET_swbreak_feature
,
2075 /* Support for hwbreak+ feature. */
2076 PACKET_hwbreak_feature
,
2078 /* Support for fork events. */
2079 PACKET_fork_event_feature
,
2081 /* Support for vfork events. */
2082 PACKET_vfork_event_feature
,
2084 /* Support for the Qbtrace-conf:pt:size packet. */
2085 PACKET_Qbtrace_conf_pt_size
,
2087 /* Support for exec events. */
2088 PACKET_exec_event_feature
,
2090 /* Support for query supported vCont actions. */
2091 PACKET_vContSupported
,
2093 /* Support remote CTRL-C. */
2096 /* Support TARGET_WAITKIND_NO_RESUMED. */
2102 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
2104 /* Returns the packet's corresponding "set remote foo-packet" command
2105 state. See struct packet_config for more details. */
2107 static enum auto_boolean
2108 packet_set_cmd_state (int packet
)
2110 return remote_protocol_packets
[packet
].detect
;
2113 /* Returns whether a given packet or feature is supported. This takes
2114 into account the state of the corresponding "set remote foo-packet"
2115 command, which may be used to bypass auto-detection. */
2117 static enum packet_support
2118 packet_config_support (struct packet_config
*config
)
2120 switch (config
->detect
)
2122 case AUTO_BOOLEAN_TRUE
:
2123 return PACKET_ENABLE
;
2124 case AUTO_BOOLEAN_FALSE
:
2125 return PACKET_DISABLE
;
2126 case AUTO_BOOLEAN_AUTO
:
2127 return config
->support
;
2129 gdb_assert_not_reached (_("bad switch"));
2133 /* Same as packet_config_support, but takes the packet's enum value as
2136 static enum packet_support
2137 packet_support (int packet
)
2139 struct packet_config
*config
= &remote_protocol_packets
[packet
];
2141 return packet_config_support (config
);
2145 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
2146 struct cmd_list_element
*c
,
2149 struct packet_config
*packet
;
2151 for (packet
= remote_protocol_packets
;
2152 packet
< &remote_protocol_packets
[PACKET_MAX
];
2155 if (&packet
->detect
== c
->var
)
2157 show_packet_config_cmd (packet
);
2161 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
2165 /* Should we try one of the 'Z' requests? */
2169 Z_PACKET_SOFTWARE_BP
,
2170 Z_PACKET_HARDWARE_BP
,
2177 /* For compatibility with older distributions. Provide a ``set remote
2178 Z-packet ...'' command that updates all the Z packet types. */
2180 static enum auto_boolean remote_Z_packet_detect
;
2183 set_remote_protocol_Z_packet_cmd (const char *args
, int from_tty
,
2184 struct cmd_list_element
*c
)
2188 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2189 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
2193 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
2194 struct cmd_list_element
*c
,
2199 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
2201 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
2205 /* Returns true if the multi-process extensions are in effect. */
2208 remote_multi_process_p (struct remote_state
*rs
)
2210 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
2213 /* Returns true if fork events are supported. */
2216 remote_fork_event_p (struct remote_state
*rs
)
2218 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
2221 /* Returns true if vfork events are supported. */
2224 remote_vfork_event_p (struct remote_state
*rs
)
2226 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
2229 /* Returns true if exec events are supported. */
2232 remote_exec_event_p (struct remote_state
*rs
)
2234 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
2237 /* Insert fork catchpoint target routine. If fork events are enabled
2238 then return success, nothing more to do. */
2241 remote_target::insert_fork_catchpoint (int pid
)
2243 struct remote_state
*rs
= get_remote_state ();
2245 return !remote_fork_event_p (rs
);
2248 /* Remove fork catchpoint target routine. Nothing to do, just
2252 remote_target::remove_fork_catchpoint (int pid
)
2257 /* Insert vfork catchpoint target routine. If vfork events are enabled
2258 then return success, nothing more to do. */
2261 remote_target::insert_vfork_catchpoint (int pid
)
2263 struct remote_state
*rs
= get_remote_state ();
2265 return !remote_vfork_event_p (rs
);
2268 /* Remove vfork catchpoint target routine. Nothing to do, just
2272 remote_target::remove_vfork_catchpoint (int pid
)
2277 /* Insert exec catchpoint target routine. If exec events are
2278 enabled, just return success. */
2281 remote_target::insert_exec_catchpoint (int pid
)
2283 struct remote_state
*rs
= get_remote_state ();
2285 return !remote_exec_event_p (rs
);
2288 /* Remove exec catchpoint target routine. Nothing to do, just
2292 remote_target::remove_exec_catchpoint (int pid
)
2299 /* Take advantage of the fact that the TID field is not used, to tag
2300 special ptids with it set to != 0. */
2301 static const ptid_t
magic_null_ptid (42000, -1, 1);
2302 static const ptid_t
not_sent_ptid (42000, -2, 1);
2303 static const ptid_t
any_thread_ptid (42000, 0, 1);
2305 /* Find out if the stub attached to PID (and hence GDB should offer to
2306 detach instead of killing it when bailing out). */
2309 remote_target::remote_query_attached (int pid
)
2311 struct remote_state
*rs
= get_remote_state ();
2312 size_t size
= get_remote_packet_size ();
2314 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
2317 if (remote_multi_process_p (rs
))
2318 xsnprintf (rs
->buf
.data (), size
, "qAttached:%x", pid
);
2320 xsnprintf (rs
->buf
.data (), size
, "qAttached");
2323 getpkt (&rs
->buf
, 0);
2325 switch (packet_ok (rs
->buf
,
2326 &remote_protocol_packets
[PACKET_qAttached
]))
2329 if (strcmp (rs
->buf
.data (), "1") == 0)
2333 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
2335 case PACKET_UNKNOWN
:
2342 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
2343 has been invented by GDB, instead of reported by the target. Since
2344 we can be connected to a remote system before before knowing about
2345 any inferior, mark the target with execution when we find the first
2346 inferior. If ATTACHED is 1, then we had just attached to this
2347 inferior. If it is 0, then we just created this inferior. If it
2348 is -1, then try querying the remote stub to find out if it had
2349 attached to the inferior or not. If TRY_OPEN_EXEC is true then
2350 attempt to open this inferior's executable as the main executable
2351 if no main executable is open already. */
2354 remote_target::remote_add_inferior (int fake_pid_p
, int pid
, int attached
,
2357 struct inferior
*inf
;
2359 /* Check whether this process we're learning about is to be
2360 considered attached, or if is to be considered to have been
2361 spawned by the stub. */
2363 attached
= remote_query_attached (pid
);
2365 if (gdbarch_has_global_solist (target_gdbarch ()))
2367 /* If the target shares code across all inferiors, then every
2368 attach adds a new inferior. */
2369 inf
= add_inferior (pid
);
2371 /* ... and every inferior is bound to the same program space.
2372 However, each inferior may still have its own address
2374 inf
->aspace
= maybe_new_address_space ();
2375 inf
->pspace
= current_program_space
;
2379 /* In the traditional debugging scenario, there's a 1-1 match
2380 between program/address spaces. We simply bind the inferior
2381 to the program space's address space. */
2382 inf
= current_inferior ();
2383 inferior_appeared (inf
, pid
);
2386 inf
->attach_flag
= attached
;
2387 inf
->fake_pid_p
= fake_pid_p
;
2389 /* If no main executable is currently open then attempt to
2390 open the file that was executed to create this inferior. */
2391 if (try_open_exec
&& get_exec_file (0) == NULL
)
2392 exec_file_locate_attach (pid
, 0, 1);
2397 static remote_thread_info
*get_remote_thread_info (thread_info
*thread
);
2398 static remote_thread_info
*get_remote_thread_info (ptid_t ptid
);
2400 /* Add thread PTID to GDB's thread list. Tag it as executing/running
2401 according to RUNNING. */
2404 remote_target::remote_add_thread (ptid_t ptid
, bool running
, bool executing
)
2406 struct remote_state
*rs
= get_remote_state ();
2407 struct thread_info
*thread
;
2409 /* GDB historically didn't pull threads in the initial connection
2410 setup. If the remote target doesn't even have a concept of
2411 threads (e.g., a bare-metal target), even if internally we
2412 consider that a single-threaded target, mentioning a new thread
2413 might be confusing to the user. Be silent then, preserving the
2414 age old behavior. */
2415 if (rs
->starting_up
)
2416 thread
= add_thread_silent (ptid
);
2418 thread
= add_thread (ptid
);
2420 get_remote_thread_info (thread
)->vcont_resumed
= executing
;
2421 set_executing (ptid
, executing
);
2422 set_running (ptid
, running
);
2427 /* Come here when we learn about a thread id from the remote target.
2428 It may be the first time we hear about such thread, so take the
2429 opportunity to add it to GDB's thread list. In case this is the
2430 first time we're noticing its corresponding inferior, add it to
2431 GDB's inferior list as well. EXECUTING indicates whether the
2432 thread is (internally) executing or stopped. */
2435 remote_target::remote_notice_new_inferior (ptid_t currthread
, int executing
)
2437 /* In non-stop mode, we assume new found threads are (externally)
2438 running until proven otherwise with a stop reply. In all-stop,
2439 we can only get here if all threads are stopped. */
2440 int running
= target_is_non_stop_p () ? 1 : 0;
2442 /* If this is a new thread, add it to GDB's thread list.
2443 If we leave it up to WFI to do this, bad things will happen. */
2445 thread_info
*tp
= find_thread_ptid (currthread
);
2446 if (tp
!= NULL
&& tp
->state
== THREAD_EXITED
)
2448 /* We're seeing an event on a thread id we knew had exited.
2449 This has to be a new thread reusing the old id. Add it. */
2450 remote_add_thread (currthread
, running
, executing
);
2454 if (!in_thread_list (currthread
))
2456 struct inferior
*inf
= NULL
;
2457 int pid
= currthread
.pid ();
2459 if (inferior_ptid
.is_pid ()
2460 && pid
== inferior_ptid
.pid ())
2462 /* inferior_ptid has no thread member yet. This can happen
2463 with the vAttach -> remote_wait,"TAAthread:" path if the
2464 stub doesn't support qC. This is the first stop reported
2465 after an attach, so this is the main thread. Update the
2466 ptid in the thread list. */
2467 if (in_thread_list (ptid_t (pid
)))
2468 thread_change_ptid (inferior_ptid
, currthread
);
2471 remote_add_thread (currthread
, running
, executing
);
2472 inferior_ptid
= currthread
;
2477 if (magic_null_ptid
== inferior_ptid
)
2479 /* inferior_ptid is not set yet. This can happen with the
2480 vRun -> remote_wait,"TAAthread:" path if the stub
2481 doesn't support qC. This is the first stop reported
2482 after an attach, so this is the main thread. Update the
2483 ptid in the thread list. */
2484 thread_change_ptid (inferior_ptid
, currthread
);
2488 /* When connecting to a target remote, or to a target
2489 extended-remote which already was debugging an inferior, we
2490 may not know about it yet. Add it before adding its child
2491 thread, so notifications are emitted in a sensible order. */
2492 if (find_inferior_pid (currthread
.pid ()) == NULL
)
2494 struct remote_state
*rs
= get_remote_state ();
2495 int fake_pid_p
= !remote_multi_process_p (rs
);
2497 inf
= remote_add_inferior (fake_pid_p
,
2498 currthread
.pid (), -1, 1);
2501 /* This is really a new thread. Add it. */
2502 thread_info
*new_thr
2503 = remote_add_thread (currthread
, running
, executing
);
2505 /* If we found a new inferior, let the common code do whatever
2506 it needs to with it (e.g., read shared libraries, insert
2507 breakpoints), unless we're just setting up an all-stop
2511 struct remote_state
*rs
= get_remote_state ();
2513 if (!rs
->starting_up
)
2514 notice_new_inferior (new_thr
, executing
, 0);
2519 /* Return THREAD's private thread data, creating it if necessary. */
2521 static remote_thread_info
*
2522 get_remote_thread_info (thread_info
*thread
)
2524 gdb_assert (thread
!= NULL
);
2526 if (thread
->priv
== NULL
)
2527 thread
->priv
.reset (new remote_thread_info
);
2529 return static_cast<remote_thread_info
*> (thread
->priv
.get ());
2532 static remote_thread_info
*
2533 get_remote_thread_info (ptid_t ptid
)
2535 thread_info
*thr
= find_thread_ptid (ptid
);
2536 return get_remote_thread_info (thr
);
2539 /* Call this function as a result of
2540 1) A halt indication (T packet) containing a thread id
2541 2) A direct query of currthread
2542 3) Successful execution of set thread */
2545 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2547 rs
->general_thread
= currthread
;
2550 /* If 'QPassSignals' is supported, tell the remote stub what signals
2551 it can simply pass through to the inferior without reporting. */
2554 remote_target::pass_signals (gdb::array_view
<const unsigned char> pass_signals
)
2556 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2558 char *pass_packet
, *p
;
2560 struct remote_state
*rs
= get_remote_state ();
2562 gdb_assert (pass_signals
.size () < 256);
2563 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2565 if (pass_signals
[i
])
2568 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2569 strcpy (pass_packet
, "QPassSignals:");
2570 p
= pass_packet
+ strlen (pass_packet
);
2571 for (size_t i
= 0; i
< pass_signals
.size (); i
++)
2573 if (pass_signals
[i
])
2576 *p
++ = tohex (i
>> 4);
2577 *p
++ = tohex (i
& 15);
2586 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2588 putpkt (pass_packet
);
2589 getpkt (&rs
->buf
, 0);
2590 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2591 if (rs
->last_pass_packet
)
2592 xfree (rs
->last_pass_packet
);
2593 rs
->last_pass_packet
= pass_packet
;
2596 xfree (pass_packet
);
2600 /* If 'QCatchSyscalls' is supported, tell the remote stub
2601 to report syscalls to GDB. */
2604 remote_target::set_syscall_catchpoint (int pid
, bool needed
, int any_count
,
2605 gdb::array_view
<const int> syscall_counts
)
2607 const char *catch_packet
;
2608 enum packet_result result
;
2611 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2613 /* Not supported. */
2617 if (needed
&& any_count
== 0)
2619 /* Count how many syscalls are to be caught. */
2620 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2622 if (syscall_counts
[i
] != 0)
2629 fprintf_unfiltered (gdb_stdlog
,
2630 "remote_set_syscall_catchpoint "
2631 "pid %d needed %d any_count %d n_sysno %d\n",
2632 pid
, needed
, any_count
, n_sysno
);
2635 std::string built_packet
;
2638 /* Prepare a packet with the sysno list, assuming max 8+1
2639 characters for a sysno. If the resulting packet size is too
2640 big, fallback on the non-selective packet. */
2641 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2642 built_packet
.reserve (maxpktsz
);
2643 built_packet
= "QCatchSyscalls:1";
2646 /* Add in each syscall to be caught. */
2647 for (size_t i
= 0; i
< syscall_counts
.size (); i
++)
2649 if (syscall_counts
[i
] != 0)
2650 string_appendf (built_packet
, ";%zx", i
);
2653 if (built_packet
.size () > get_remote_packet_size ())
2655 /* catch_packet too big. Fallback to less efficient
2656 non selective mode, with GDB doing the filtering. */
2657 catch_packet
= "QCatchSyscalls:1";
2660 catch_packet
= built_packet
.c_str ();
2663 catch_packet
= "QCatchSyscalls:0";
2665 struct remote_state
*rs
= get_remote_state ();
2667 putpkt (catch_packet
);
2668 getpkt (&rs
->buf
, 0);
2669 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2670 if (result
== PACKET_OK
)
2676 /* If 'QProgramSignals' is supported, tell the remote stub what
2677 signals it should pass through to the inferior when detaching. */
2680 remote_target::program_signals (gdb::array_view
<const unsigned char> signals
)
2682 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2686 struct remote_state
*rs
= get_remote_state ();
2688 gdb_assert (signals
.size () < 256);
2689 for (size_t i
= 0; i
< signals
.size (); i
++)
2694 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2695 strcpy (packet
, "QProgramSignals:");
2696 p
= packet
+ strlen (packet
);
2697 for (size_t i
= 0; i
< signals
.size (); i
++)
2699 if (signal_pass_state (i
))
2702 *p
++ = tohex (i
>> 4);
2703 *p
++ = tohex (i
& 15);
2712 if (!rs
->last_program_signals_packet
2713 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2716 getpkt (&rs
->buf
, 0);
2717 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2718 xfree (rs
->last_program_signals_packet
);
2719 rs
->last_program_signals_packet
= packet
;
2726 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2727 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2728 thread. If GEN is set, set the general thread, if not, then set
2729 the step/continue thread. */
2731 remote_target::set_thread (ptid_t ptid
, int gen
)
2733 struct remote_state
*rs
= get_remote_state ();
2734 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2735 char *buf
= rs
->buf
.data ();
2736 char *endbuf
= buf
+ get_remote_packet_size ();
2742 *buf
++ = gen
? 'g' : 'c';
2743 if (ptid
== magic_null_ptid
)
2744 xsnprintf (buf
, endbuf
- buf
, "0");
2745 else if (ptid
== any_thread_ptid
)
2746 xsnprintf (buf
, endbuf
- buf
, "0");
2747 else if (ptid
== minus_one_ptid
)
2748 xsnprintf (buf
, endbuf
- buf
, "-1");
2750 write_ptid (buf
, endbuf
, ptid
);
2752 getpkt (&rs
->buf
, 0);
2754 rs
->general_thread
= ptid
;
2756 rs
->continue_thread
= ptid
;
2760 remote_target::set_general_thread (ptid_t ptid
)
2762 set_thread (ptid
, 1);
2766 remote_target::set_continue_thread (ptid_t ptid
)
2768 set_thread (ptid
, 0);
2771 /* Change the remote current process. Which thread within the process
2772 ends up selected isn't important, as long as it is the same process
2773 as what INFERIOR_PTID points to.
2775 This comes from that fact that there is no explicit notion of
2776 "selected process" in the protocol. The selected process for
2777 general operations is the process the selected general thread
2781 remote_target::set_general_process ()
2783 struct remote_state
*rs
= get_remote_state ();
2785 /* If the remote can't handle multiple processes, don't bother. */
2786 if (!remote_multi_process_p (rs
))
2789 /* We only need to change the remote current thread if it's pointing
2790 at some other process. */
2791 if (rs
->general_thread
.pid () != inferior_ptid
.pid ())
2792 set_general_thread (inferior_ptid
);
2796 /* Return nonzero if this is the main thread that we made up ourselves
2797 to model non-threaded targets as single-threaded. */
2800 remote_thread_always_alive (ptid_t ptid
)
2802 if (ptid
== magic_null_ptid
)
2803 /* The main thread is always alive. */
2806 if (ptid
.pid () != 0 && ptid
.lwp () == 0)
2807 /* The main thread is always alive. This can happen after a
2808 vAttach, if the remote side doesn't support
2815 /* Return nonzero if the thread PTID is still alive on the remote
2819 remote_target::thread_alive (ptid_t ptid
)
2821 struct remote_state
*rs
= get_remote_state ();
2824 /* Check if this is a thread that we made up ourselves to model
2825 non-threaded targets as single-threaded. */
2826 if (remote_thread_always_alive (ptid
))
2829 p
= rs
->buf
.data ();
2830 endp
= p
+ get_remote_packet_size ();
2833 write_ptid (p
, endp
, ptid
);
2836 getpkt (&rs
->buf
, 0);
2837 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2840 /* Return a pointer to a thread name if we know it and NULL otherwise.
2841 The thread_info object owns the memory for the name. */
2844 remote_target::thread_name (struct thread_info
*info
)
2846 if (info
->priv
!= NULL
)
2848 const std::string
&name
= get_remote_thread_info (info
)->name
;
2849 return !name
.empty () ? name
.c_str () : NULL
;
2855 /* About these extended threadlist and threadinfo packets. They are
2856 variable length packets but, the fields within them are often fixed
2857 length. They are redundent enough to send over UDP as is the
2858 remote protocol in general. There is a matching unit test module
2861 /* WARNING: This threadref data structure comes from the remote O.S.,
2862 libstub protocol encoding, and remote.c. It is not particularly
2865 /* Right now, the internal structure is int. We want it to be bigger.
2866 Plan to fix this. */
2868 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2870 /* gdb_ext_thread_info is an internal GDB data structure which is
2871 equivalent to the reply of the remote threadinfo packet. */
2873 struct gdb_ext_thread_info
2875 threadref threadid
; /* External form of thread reference. */
2876 int active
; /* Has state interesting to GDB?
2878 char display
[256]; /* Brief state display, name,
2879 blocked/suspended. */
2880 char shortname
[32]; /* To be used to name threads. */
2881 char more_display
[256]; /* Long info, statistics, queue depth,
2885 /* The volume of remote transfers can be limited by submitting
2886 a mask containing bits specifying the desired information.
2887 Use a union of these values as the 'selection' parameter to
2888 get_thread_info. FIXME: Make these TAG names more thread specific. */
2890 #define TAG_THREADID 1
2891 #define TAG_EXISTS 2
2892 #define TAG_DISPLAY 4
2893 #define TAG_THREADNAME 8
2894 #define TAG_MOREDISPLAY 16
2896 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2898 static char *unpack_nibble (char *buf
, int *val
);
2900 static char *unpack_byte (char *buf
, int *value
);
2902 static char *pack_int (char *buf
, int value
);
2904 static char *unpack_int (char *buf
, int *value
);
2906 static char *unpack_string (char *src
, char *dest
, int length
);
2908 static char *pack_threadid (char *pkt
, threadref
*id
);
2910 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2912 void int_to_threadref (threadref
*id
, int value
);
2914 static int threadref_to_int (threadref
*ref
);
2916 static void copy_threadref (threadref
*dest
, threadref
*src
);
2918 static int threadmatch (threadref
*dest
, threadref
*src
);
2920 static char *pack_threadinfo_request (char *pkt
, int mode
,
2923 static char *pack_threadlist_request (char *pkt
, int startflag
,
2925 threadref
*nextthread
);
2927 static int remote_newthread_step (threadref
*ref
, void *context
);
2930 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2931 buffer we're allowed to write to. Returns
2932 BUF+CHARACTERS_WRITTEN. */
2935 remote_target::write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2938 struct remote_state
*rs
= get_remote_state ();
2940 if (remote_multi_process_p (rs
))
2944 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2946 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2950 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2952 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2957 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2958 last parsed char. Returns null_ptid if no thread id is found, and
2959 throws an error if the thread id has an invalid format. */
2962 read_ptid (const char *buf
, const char **obuf
)
2964 const char *p
= buf
;
2966 ULONGEST pid
= 0, tid
= 0;
2970 /* Multi-process ptid. */
2971 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2973 error (_("invalid remote ptid: %s"), p
);
2976 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2979 return ptid_t (pid
, tid
, 0);
2982 /* No multi-process. Just a tid. */
2983 pp
= unpack_varlen_hex (p
, &tid
);
2985 /* Return null_ptid when no thread id is found. */
2993 /* Since the stub is not sending a process id, then default to
2994 what's in inferior_ptid, unless it's null at this point. If so,
2995 then since there's no way to know the pid of the reported
2996 threads, use the magic number. */
2997 if (inferior_ptid
== null_ptid
)
2998 pid
= magic_null_ptid
.pid ();
3000 pid
= inferior_ptid
.pid ();
3004 return ptid_t (pid
, tid
, 0);
3010 if (ch
>= 'a' && ch
<= 'f')
3011 return ch
- 'a' + 10;
3012 if (ch
>= '0' && ch
<= '9')
3014 if (ch
>= 'A' && ch
<= 'F')
3015 return ch
- 'A' + 10;
3020 stub_unpack_int (char *buff
, int fieldlength
)
3027 nibble
= stubhex (*buff
++);
3031 retval
= retval
<< 4;
3037 unpack_nibble (char *buf
, int *val
)
3039 *val
= fromhex (*buf
++);
3044 unpack_byte (char *buf
, int *value
)
3046 *value
= stub_unpack_int (buf
, 2);
3051 pack_int (char *buf
, int value
)
3053 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
3054 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
3055 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
3056 buf
= pack_hex_byte (buf
, (value
& 0xff));
3061 unpack_int (char *buf
, int *value
)
3063 *value
= stub_unpack_int (buf
, 8);
3067 #if 0 /* Currently unused, uncomment when needed. */
3068 static char *pack_string (char *pkt
, char *string
);
3071 pack_string (char *pkt
, char *string
)
3076 len
= strlen (string
);
3078 len
= 200; /* Bigger than most GDB packets, junk??? */
3079 pkt
= pack_hex_byte (pkt
, len
);
3083 if ((ch
== '\0') || (ch
== '#'))
3084 ch
= '*'; /* Protect encapsulation. */
3089 #endif /* 0 (unused) */
3092 unpack_string (char *src
, char *dest
, int length
)
3101 pack_threadid (char *pkt
, threadref
*id
)
3104 unsigned char *altid
;
3106 altid
= (unsigned char *) id
;
3107 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
3109 pkt
= pack_hex_byte (pkt
, *altid
++);
3115 unpack_threadid (char *inbuf
, threadref
*id
)
3118 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
3121 altref
= (char *) id
;
3123 while (inbuf
< limit
)
3125 x
= stubhex (*inbuf
++);
3126 y
= stubhex (*inbuf
++);
3127 *altref
++ = (x
<< 4) | y
;
3132 /* Externally, threadrefs are 64 bits but internally, they are still
3133 ints. This is due to a mismatch of specifications. We would like
3134 to use 64bit thread references internally. This is an adapter
3138 int_to_threadref (threadref
*id
, int value
)
3140 unsigned char *scan
;
3142 scan
= (unsigned char *) id
;
3148 *scan
++ = (value
>> 24) & 0xff;
3149 *scan
++ = (value
>> 16) & 0xff;
3150 *scan
++ = (value
>> 8) & 0xff;
3151 *scan
++ = (value
& 0xff);
3155 threadref_to_int (threadref
*ref
)
3158 unsigned char *scan
;
3164 value
= (value
<< 8) | ((*scan
++) & 0xff);
3169 copy_threadref (threadref
*dest
, threadref
*src
)
3172 unsigned char *csrc
, *cdest
;
3174 csrc
= (unsigned char *) src
;
3175 cdest
= (unsigned char *) dest
;
3182 threadmatch (threadref
*dest
, threadref
*src
)
3184 /* Things are broken right now, so just assume we got a match. */
3186 unsigned char *srcp
, *destp
;
3188 srcp
= (char *) src
;
3189 destp
= (char *) dest
;
3193 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
3200 threadid:1, # always request threadid
3207 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
3210 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
3212 *pkt
++ = 'q'; /* Info Query */
3213 *pkt
++ = 'P'; /* process or thread info */
3214 pkt
= pack_int (pkt
, mode
); /* mode */
3215 pkt
= pack_threadid (pkt
, id
); /* threadid */
3216 *pkt
= '\0'; /* terminate */
3220 /* These values tag the fields in a thread info response packet. */
3221 /* Tagging the fields allows us to request specific fields and to
3222 add more fields as time goes by. */
3224 #define TAG_THREADID 1 /* Echo the thread identifier. */
3225 #define TAG_EXISTS 2 /* Is this process defined enough to
3226 fetch registers and its stack? */
3227 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
3228 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
3229 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
3233 remote_target::remote_unpack_thread_info_response (char *pkt
,
3234 threadref
*expectedref
,
3235 gdb_ext_thread_info
*info
)
3237 struct remote_state
*rs
= get_remote_state ();
3241 char *limit
= pkt
+ rs
->buf
.size (); /* Plausible parsing limit. */
3244 /* info->threadid = 0; FIXME: implement zero_threadref. */
3246 info
->display
[0] = '\0';
3247 info
->shortname
[0] = '\0';
3248 info
->more_display
[0] = '\0';
3250 /* Assume the characters indicating the packet type have been
3252 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
3253 pkt
= unpack_threadid (pkt
, &ref
);
3256 warning (_("Incomplete response to threadinfo request."));
3257 if (!threadmatch (&ref
, expectedref
))
3258 { /* This is an answer to a different request. */
3259 warning (_("ERROR RMT Thread info mismatch."));
3262 copy_threadref (&info
->threadid
, &ref
);
3264 /* Loop on tagged fields , try to bail if somthing goes wrong. */
3266 /* Packets are terminated with nulls. */
3267 while ((pkt
< limit
) && mask
&& *pkt
)
3269 pkt
= unpack_int (pkt
, &tag
); /* tag */
3270 pkt
= unpack_byte (pkt
, &length
); /* length */
3271 if (!(tag
& mask
)) /* Tags out of synch with mask. */
3273 warning (_("ERROR RMT: threadinfo tag mismatch."));
3277 if (tag
== TAG_THREADID
)
3281 warning (_("ERROR RMT: length of threadid is not 16."));
3285 pkt
= unpack_threadid (pkt
, &ref
);
3286 mask
= mask
& ~TAG_THREADID
;
3289 if (tag
== TAG_EXISTS
)
3291 info
->active
= stub_unpack_int (pkt
, length
);
3293 mask
= mask
& ~(TAG_EXISTS
);
3296 warning (_("ERROR RMT: 'exists' length too long."));
3302 if (tag
== TAG_THREADNAME
)
3304 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
3305 mask
= mask
& ~TAG_THREADNAME
;
3308 if (tag
== TAG_DISPLAY
)
3310 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
3311 mask
= mask
& ~TAG_DISPLAY
;
3314 if (tag
== TAG_MOREDISPLAY
)
3316 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
3317 mask
= mask
& ~TAG_MOREDISPLAY
;
3320 warning (_("ERROR RMT: unknown thread info tag."));
3321 break; /* Not a tag we know about. */
3327 remote_target::remote_get_threadinfo (threadref
*threadid
,
3329 gdb_ext_thread_info
*info
)
3331 struct remote_state
*rs
= get_remote_state ();
3334 pack_threadinfo_request (rs
->buf
.data (), fieldset
, threadid
);
3336 getpkt (&rs
->buf
, 0);
3338 if (rs
->buf
[0] == '\0')
3341 result
= remote_unpack_thread_info_response (&rs
->buf
[2],
3346 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
3349 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
3350 threadref
*nextthread
)
3352 *pkt
++ = 'q'; /* info query packet */
3353 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
3354 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
3355 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
3356 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
3361 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3364 remote_target::parse_threadlist_response (char *pkt
, int result_limit
,
3365 threadref
*original_echo
,
3366 threadref
*resultlist
,
3369 struct remote_state
*rs
= get_remote_state ();
3371 int count
, resultcount
, done
;
3374 /* Assume the 'q' and 'M chars have been stripped. */
3375 limit
= pkt
+ (rs
->buf
.size () - BUF_THREAD_ID_SIZE
);
3376 /* done parse past here */
3377 pkt
= unpack_byte (pkt
, &count
); /* count field */
3378 pkt
= unpack_nibble (pkt
, &done
);
3379 /* The first threadid is the argument threadid. */
3380 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
3381 while ((count
-- > 0) && (pkt
< limit
))
3383 pkt
= unpack_threadid (pkt
, resultlist
++);
3384 if (resultcount
++ >= result_limit
)
3392 /* Fetch the next batch of threads from the remote. Returns -1 if the
3393 qL packet is not supported, 0 on error and 1 on success. */
3396 remote_target::remote_get_threadlist (int startflag
, threadref
*nextthread
,
3397 int result_limit
, int *done
, int *result_count
,
3398 threadref
*threadlist
)
3400 struct remote_state
*rs
= get_remote_state ();
3403 /* Trancate result limit to be smaller than the packet size. */
3404 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
3405 >= get_remote_packet_size ())
3406 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
3408 pack_threadlist_request (rs
->buf
.data (), startflag
, result_limit
,
3411 getpkt (&rs
->buf
, 0);
3412 if (rs
->buf
[0] == '\0')
3414 /* Packet not supported. */
3419 parse_threadlist_response (&rs
->buf
[2], result_limit
,
3420 &rs
->echo_nextthread
, threadlist
, done
);
3422 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
3424 /* FIXME: This is a good reason to drop the packet. */
3425 /* Possably, there is a duplicate response. */
3427 retransmit immediatly - race conditions
3428 retransmit after timeout - yes
3430 wait for packet, then exit
3432 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3433 return 0; /* I choose simply exiting. */
3435 if (*result_count
<= 0)
3439 warning (_("RMT ERROR : failed to get remote thread list."));
3442 return result
; /* break; */
3444 if (*result_count
> result_limit
)
3447 warning (_("RMT ERROR: threadlist response longer than requested."));
3453 /* Fetch the list of remote threads, with the qL packet, and call
3454 STEPFUNCTION for each thread found. Stops iterating and returns 1
3455 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
3456 STEPFUNCTION returns false. If the packet is not supported,
3460 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction
,
3461 void *context
, int looplimit
)
3463 struct remote_state
*rs
= get_remote_state ();
3464 int done
, i
, result_count
;
3472 if (loopcount
++ > looplimit
)
3475 warning (_("Remote fetch threadlist -infinite loop-."));
3478 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
3479 MAXTHREADLISTRESULTS
,
3480 &done
, &result_count
,
3481 rs
->resultthreadlist
);
3484 /* Clear for later iterations. */
3486 /* Setup to resume next batch of thread references, set nextthread. */
3487 if (result_count
>= 1)
3488 copy_threadref (&rs
->nextthread
,
3489 &rs
->resultthreadlist
[result_count
- 1]);
3491 while (result_count
--)
3493 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
3503 /* A thread found on the remote target. */
3507 explicit thread_item (ptid_t ptid_
)
3511 thread_item (thread_item
&&other
) = default;
3512 thread_item
&operator= (thread_item
&&other
) = default;
3514 DISABLE_COPY_AND_ASSIGN (thread_item
);
3516 /* The thread's PTID. */
3519 /* The thread's extra info. */
3522 /* The thread's name. */
3525 /* The core the thread was running on. -1 if not known. */
3528 /* The thread handle associated with the thread. */
3529 gdb::byte_vector thread_handle
;
3532 /* Context passed around to the various methods listing remote
3533 threads. As new threads are found, they're added to the ITEMS
3536 struct threads_listing_context
3538 /* Return true if this object contains an entry for a thread with ptid
3541 bool contains_thread (ptid_t ptid
) const
3543 auto match_ptid
= [&] (const thread_item
&item
)
3545 return item
.ptid
== ptid
;
3548 auto it
= std::find_if (this->items
.begin (),
3552 return it
!= this->items
.end ();
3555 /* Remove the thread with ptid PTID. */
3557 void remove_thread (ptid_t ptid
)
3559 auto match_ptid
= [&] (const thread_item
&item
)
3561 return item
.ptid
== ptid
;
3564 auto it
= std::remove_if (this->items
.begin (),
3568 if (it
!= this->items
.end ())
3569 this->items
.erase (it
);
3572 /* The threads found on the remote target. */
3573 std::vector
<thread_item
> items
;
3577 remote_newthread_step (threadref
*ref
, void *data
)
3579 struct threads_listing_context
*context
3580 = (struct threads_listing_context
*) data
;
3581 int pid
= inferior_ptid
.pid ();
3582 int lwp
= threadref_to_int (ref
);
3583 ptid_t
ptid (pid
, lwp
);
3585 context
->items
.emplace_back (ptid
);
3587 return 1; /* continue iterator */
3590 #define CRAZY_MAX_THREADS 1000
3593 remote_target::remote_current_thread (ptid_t oldpid
)
3595 struct remote_state
*rs
= get_remote_state ();
3598 getpkt (&rs
->buf
, 0);
3599 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3604 result
= read_ptid (&rs
->buf
[2], &obuf
);
3605 if (*obuf
!= '\0' && remote_debug
)
3606 fprintf_unfiltered (gdb_stdlog
,
3607 "warning: garbage in qC reply\n");
3615 /* List remote threads using the deprecated qL packet. */
3618 remote_target::remote_get_threads_with_ql (threads_listing_context
*context
)
3620 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3621 CRAZY_MAX_THREADS
) >= 0)
3627 #if defined(HAVE_LIBEXPAT)
3630 start_thread (struct gdb_xml_parser
*parser
,
3631 const struct gdb_xml_element
*element
,
3633 std::vector
<gdb_xml_value
> &attributes
)
3635 struct threads_listing_context
*data
3636 = (struct threads_listing_context
*) user_data
;
3637 struct gdb_xml_value
*attr
;
3639 char *id
= (char *) xml_find_attribute (attributes
, "id")->value
.get ();
3640 ptid_t ptid
= read_ptid (id
, NULL
);
3642 data
->items
.emplace_back (ptid
);
3643 thread_item
&item
= data
->items
.back ();
3645 attr
= xml_find_attribute (attributes
, "core");
3647 item
.core
= *(ULONGEST
*) attr
->value
.get ();
3649 attr
= xml_find_attribute (attributes
, "name");
3651 item
.name
= (const char *) attr
->value
.get ();
3653 attr
= xml_find_attribute (attributes
, "handle");
3655 item
.thread_handle
= hex2bin ((const char *) attr
->value
.get ());
3659 end_thread (struct gdb_xml_parser
*parser
,
3660 const struct gdb_xml_element
*element
,
3661 void *user_data
, const char *body_text
)
3663 struct threads_listing_context
*data
3664 = (struct threads_listing_context
*) user_data
;
3666 if (body_text
!= NULL
&& *body_text
!= '\0')
3667 data
->items
.back ().extra
= body_text
;
3670 const struct gdb_xml_attribute thread_attributes
[] = {
3671 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3672 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3673 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3674 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3675 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3678 const struct gdb_xml_element thread_children
[] = {
3679 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3682 const struct gdb_xml_element threads_children
[] = {
3683 { "thread", thread_attributes
, thread_children
,
3684 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3685 start_thread
, end_thread
},
3686 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3689 const struct gdb_xml_element threads_elements
[] = {
3690 { "threads", NULL
, threads_children
,
3691 GDB_XML_EF_NONE
, NULL
, NULL
},
3692 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3697 /* List remote threads using qXfer:threads:read. */
3700 remote_target::remote_get_threads_with_qxfer (threads_listing_context
*context
)
3702 #if defined(HAVE_LIBEXPAT)
3703 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3705 gdb::optional
<gdb::char_vector
> xml
3706 = target_read_stralloc (this, TARGET_OBJECT_THREADS
, NULL
);
3708 if (xml
&& (*xml
)[0] != '\0')
3710 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3711 threads_elements
, xml
->data (), context
);
3721 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3724 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context
*context
)
3726 struct remote_state
*rs
= get_remote_state ();
3728 if (rs
->use_threadinfo_query
)
3732 putpkt ("qfThreadInfo");
3733 getpkt (&rs
->buf
, 0);
3734 bufp
= rs
->buf
.data ();
3735 if (bufp
[0] != '\0') /* q packet recognized */
3737 while (*bufp
++ == 'm') /* reply contains one or more TID */
3741 ptid_t ptid
= read_ptid (bufp
, &bufp
);
3742 context
->items
.emplace_back (ptid
);
3744 while (*bufp
++ == ','); /* comma-separated list */
3745 putpkt ("qsThreadInfo");
3746 getpkt (&rs
->buf
, 0);
3747 bufp
= rs
->buf
.data ();
3753 /* Packet not recognized. */
3754 rs
->use_threadinfo_query
= 0;
3761 /* Implement the to_update_thread_list function for the remote
3765 remote_target::update_thread_list ()
3767 struct threads_listing_context context
;
3770 /* We have a few different mechanisms to fetch the thread list. Try
3771 them all, starting with the most preferred one first, falling
3772 back to older methods. */
3773 if (remote_get_threads_with_qxfer (&context
)
3774 || remote_get_threads_with_qthreadinfo (&context
)
3775 || remote_get_threads_with_ql (&context
))
3779 if (context
.items
.empty ()
3780 && remote_thread_always_alive (inferior_ptid
))
3782 /* Some targets don't really support threads, but still
3783 reply an (empty) thread list in response to the thread
3784 listing packets, instead of replying "packet not
3785 supported". Exit early so we don't delete the main
3790 /* CONTEXT now holds the current thread list on the remote
3791 target end. Delete GDB-side threads no longer found on the
3793 for (thread_info
*tp
: all_threads_safe ())
3795 if (!context
.contains_thread (tp
->ptid
))
3802 /* Remove any unreported fork child threads from CONTEXT so
3803 that we don't interfere with follow fork, which is where
3804 creation of such threads is handled. */
3805 remove_new_fork_children (&context
);
3807 /* And now add threads we don't know about yet to our list. */
3808 for (thread_item
&item
: context
.items
)
3810 if (item
.ptid
!= null_ptid
)
3812 /* In non-stop mode, we assume new found threads are
3813 executing until proven otherwise with a stop reply.
3814 In all-stop, we can only get here if all threads are
3816 int executing
= target_is_non_stop_p () ? 1 : 0;
3818 remote_notice_new_inferior (item
.ptid
, executing
);
3820 thread_info
*tp
= find_thread_ptid (item
.ptid
);
3821 remote_thread_info
*info
= get_remote_thread_info (tp
);
3822 info
->core
= item
.core
;
3823 info
->extra
= std::move (item
.extra
);
3824 info
->name
= std::move (item
.name
);
3825 info
->thread_handle
= std::move (item
.thread_handle
);
3832 /* If no thread listing method is supported, then query whether
3833 each known thread is alive, one by one, with the T packet.
3834 If the target doesn't support threads at all, then this is a
3835 no-op. See remote_thread_alive. */
3841 * Collect a descriptive string about the given thread.
3842 * The target may say anything it wants to about the thread
3843 * (typically info about its blocked / runnable state, name, etc.).
3844 * This string will appear in the info threads display.
3846 * Optional: targets are not required to implement this function.
3850 remote_target::extra_thread_info (thread_info
*tp
)
3852 struct remote_state
*rs
= get_remote_state ();
3855 struct gdb_ext_thread_info threadinfo
;
3857 if (rs
->remote_desc
== 0) /* paranoia */
3858 internal_error (__FILE__
, __LINE__
,
3859 _("remote_threads_extra_info"));
3861 if (tp
->ptid
== magic_null_ptid
3862 || (tp
->ptid
.pid () != 0 && tp
->ptid
.lwp () == 0))
3863 /* This is the main thread which was added by GDB. The remote
3864 server doesn't know about it. */
3867 std::string
&extra
= get_remote_thread_info (tp
)->extra
;
3869 /* If already have cached info, use it. */
3870 if (!extra
.empty ())
3871 return extra
.c_str ();
3873 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3875 /* If we're using qXfer:threads:read, then the extra info is
3876 included in the XML. So if we didn't have anything cached,
3877 it's because there's really no extra info. */
3881 if (rs
->use_threadextra_query
)
3883 char *b
= rs
->buf
.data ();
3884 char *endb
= b
+ get_remote_packet_size ();
3886 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3888 write_ptid (b
, endb
, tp
->ptid
);
3891 getpkt (&rs
->buf
, 0);
3892 if (rs
->buf
[0] != 0)
3894 extra
.resize (strlen (rs
->buf
.data ()) / 2);
3895 hex2bin (rs
->buf
.data (), (gdb_byte
*) &extra
[0], extra
.size ());
3896 return extra
.c_str ();
3900 /* If the above query fails, fall back to the old method. */
3901 rs
->use_threadextra_query
= 0;
3902 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3903 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3904 int_to_threadref (&id
, tp
->ptid
.lwp ());
3905 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3906 if (threadinfo
.active
)
3908 if (*threadinfo
.shortname
)
3909 string_appendf (extra
, " Name: %s", threadinfo
.shortname
);
3910 if (*threadinfo
.display
)
3912 if (!extra
.empty ())
3914 string_appendf (extra
, " State: %s", threadinfo
.display
);
3916 if (*threadinfo
.more_display
)
3918 if (!extra
.empty ())
3920 string_appendf (extra
, " Priority: %s", threadinfo
.more_display
);
3922 return extra
.c_str ();
3929 remote_target::static_tracepoint_marker_at (CORE_ADDR addr
,
3930 struct static_tracepoint_marker
*marker
)
3932 struct remote_state
*rs
= get_remote_state ();
3933 char *p
= rs
->buf
.data ();
3935 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3937 p
+= hexnumstr (p
, addr
);
3939 getpkt (&rs
->buf
, 0);
3940 p
= rs
->buf
.data ();
3943 error (_("Remote failure reply: %s"), p
);
3947 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3954 std::vector
<static_tracepoint_marker
>
3955 remote_target::static_tracepoint_markers_by_strid (const char *strid
)
3957 struct remote_state
*rs
= get_remote_state ();
3958 std::vector
<static_tracepoint_marker
> markers
;
3960 static_tracepoint_marker marker
;
3962 /* Ask for a first packet of static tracepoint marker
3965 getpkt (&rs
->buf
, 0);
3966 p
= rs
->buf
.data ();
3968 error (_("Remote failure reply: %s"), p
);
3974 parse_static_tracepoint_marker_definition (p
, &p
, &marker
);
3976 if (strid
== NULL
|| marker
.str_id
== strid
)
3977 markers
.push_back (std::move (marker
));
3979 while (*p
++ == ','); /* comma-separated list */
3980 /* Ask for another packet of static tracepoint definition. */
3982 getpkt (&rs
->buf
, 0);
3983 p
= rs
->buf
.data ();
3990 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3993 remote_target::get_ada_task_ptid (long lwp
, long thread
)
3995 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
3999 /* Restart the remote side; this is an extended protocol operation. */
4002 remote_target::extended_remote_restart ()
4004 struct remote_state
*rs
= get_remote_state ();
4006 /* Send the restart command; for reasons I don't understand the
4007 remote side really expects a number after the "R". */
4008 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "R%x", 0);
4011 remote_fileio_reset ();
4014 /* Clean up connection to a remote debugger. */
4017 remote_target::close ()
4019 /* Make sure we leave stdin registered in the event loop. */
4022 /* We don't have a connection to the remote stub anymore. Get rid
4023 of all the inferiors and their threads we were controlling.
4024 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4025 will be unable to find the thread corresponding to (pid, 0, 0). */
4026 inferior_ptid
= null_ptid
;
4027 discard_all_inferiors ();
4029 trace_reset_local_state ();
4034 remote_target::~remote_target ()
4036 struct remote_state
*rs
= get_remote_state ();
4038 /* Check for NULL because we may get here with a partially
4039 constructed target/connection. */
4040 if (rs
->remote_desc
== nullptr)
4043 serial_close (rs
->remote_desc
);
4045 /* We are destroying the remote target, so we should discard
4046 everything of this target. */
4047 discard_pending_stop_replies_in_queue ();
4049 if (rs
->remote_async_inferior_event_token
)
4050 delete_async_event_handler (&rs
->remote_async_inferior_event_token
);
4052 remote_notif_state_xfree (rs
->notif_state
);
4055 /* Query the remote side for the text, data and bss offsets. */
4058 remote_target::get_offsets ()
4060 struct remote_state
*rs
= get_remote_state ();
4063 int lose
, num_segments
= 0, do_sections
, do_segments
;
4064 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
4065 struct section_offsets
*offs
;
4066 struct symfile_segment_data
*data
;
4068 if (symfile_objfile
== NULL
)
4071 putpkt ("qOffsets");
4072 getpkt (&rs
->buf
, 0);
4073 buf
= rs
->buf
.data ();
4075 if (buf
[0] == '\000')
4076 return; /* Return silently. Stub doesn't support
4080 warning (_("Remote failure reply: %s"), buf
);
4084 /* Pick up each field in turn. This used to be done with scanf, but
4085 scanf will make trouble if CORE_ADDR size doesn't match
4086 conversion directives correctly. The following code will work
4087 with any size of CORE_ADDR. */
4088 text_addr
= data_addr
= bss_addr
= 0;
4092 if (startswith (ptr
, "Text="))
4095 /* Don't use strtol, could lose on big values. */
4096 while (*ptr
&& *ptr
!= ';')
4097 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4099 if (startswith (ptr
, ";Data="))
4102 while (*ptr
&& *ptr
!= ';')
4103 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4108 if (!lose
&& startswith (ptr
, ";Bss="))
4111 while (*ptr
&& *ptr
!= ';')
4112 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
4114 if (bss_addr
!= data_addr
)
4115 warning (_("Target reported unsupported offsets: %s"), buf
);
4120 else if (startswith (ptr
, "TextSeg="))
4123 /* Don't use strtol, could lose on big values. */
4124 while (*ptr
&& *ptr
!= ';')
4125 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
4128 if (startswith (ptr
, ";DataSeg="))
4131 while (*ptr
&& *ptr
!= ';')
4132 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
4140 error (_("Malformed response to offset query, %s"), buf
);
4141 else if (*ptr
!= '\0')
4142 warning (_("Target reported unsupported offsets: %s"), buf
);
4144 offs
= ((struct section_offsets
*)
4145 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
4146 memcpy (offs
, symfile_objfile
->section_offsets
,
4147 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
4149 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
4150 do_segments
= (data
!= NULL
);
4151 do_sections
= num_segments
== 0;
4153 if (num_segments
> 0)
4155 segments
[0] = text_addr
;
4156 segments
[1] = data_addr
;
4158 /* If we have two segments, we can still try to relocate everything
4159 by assuming that the .text and .data offsets apply to the whole
4160 text and data segments. Convert the offsets given in the packet
4161 to base addresses for symfile_map_offsets_to_segments. */
4162 else if (data
&& data
->num_segments
== 2)
4164 segments
[0] = data
->segment_bases
[0] + text_addr
;
4165 segments
[1] = data
->segment_bases
[1] + data_addr
;
4168 /* If the object file has only one segment, assume that it is text
4169 rather than data; main programs with no writable data are rare,
4170 but programs with no code are useless. Of course the code might
4171 have ended up in the data segment... to detect that we would need
4172 the permissions here. */
4173 else if (data
&& data
->num_segments
== 1)
4175 segments
[0] = data
->segment_bases
[0] + text_addr
;
4178 /* There's no way to relocate by segment. */
4184 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
4185 offs
, num_segments
, segments
);
4187 if (ret
== 0 && !do_sections
)
4188 error (_("Can not handle qOffsets TextSeg "
4189 "response with this symbol file"));
4196 free_symfile_segment_data (data
);
4200 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
4202 /* This is a temporary kludge to force data and bss to use the
4203 same offsets because that's what nlmconv does now. The real
4204 solution requires changes to the stub and remote.c that I
4205 don't have time to do right now. */
4207 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
4208 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
4211 objfile_relocate (symfile_objfile
, offs
);
4214 /* Send interrupt_sequence to remote target. */
4217 remote_target::send_interrupt_sequence ()
4219 struct remote_state
*rs
= get_remote_state ();
4221 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
4222 remote_serial_write ("\x03", 1);
4223 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
4224 serial_send_break (rs
->remote_desc
);
4225 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
4227 serial_send_break (rs
->remote_desc
);
4228 remote_serial_write ("g", 1);
4231 internal_error (__FILE__
, __LINE__
,
4232 _("Invalid value for interrupt_sequence_mode: %s."),
4233 interrupt_sequence_mode
);
4237 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4238 and extract the PTID. Returns NULL_PTID if not found. */
4241 stop_reply_extract_thread (char *stop_reply
)
4243 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
4247 /* Txx r:val ; r:val (...) */
4250 /* Look for "register" named "thread". */
4255 p1
= strchr (p
, ':');
4259 if (strncmp (p
, "thread", p1
- p
) == 0)
4260 return read_ptid (++p1
, &p
);
4262 p1
= strchr (p
, ';');
4274 /* Determine the remote side's current thread. If we have a stop
4275 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4276 "thread" register we can extract the current thread from. If not,
4277 ask the remote which is the current thread with qC. The former
4278 method avoids a roundtrip. */
4281 remote_target::get_current_thread (char *wait_status
)
4283 ptid_t ptid
= null_ptid
;
4285 /* Note we don't use remote_parse_stop_reply as that makes use of
4286 the target architecture, which we haven't yet fully determined at
4288 if (wait_status
!= NULL
)
4289 ptid
= stop_reply_extract_thread (wait_status
);
4290 if (ptid
== null_ptid
)
4291 ptid
= remote_current_thread (inferior_ptid
);
4296 /* Query the remote target for which is the current thread/process,
4297 add it to our tables, and update INFERIOR_PTID. The caller is
4298 responsible for setting the state such that the remote end is ready
4299 to return the current thread.
4301 This function is called after handling the '?' or 'vRun' packets,
4302 whose response is a stop reply from which we can also try
4303 extracting the thread. If the target doesn't support the explicit
4304 qC query, we infer the current thread from that stop reply, passed
4305 in in WAIT_STATUS, which may be NULL. */
4308 remote_target::add_current_inferior_and_thread (char *wait_status
)
4310 struct remote_state
*rs
= get_remote_state ();
4313 inferior_ptid
= null_ptid
;
4315 /* Now, if we have thread information, update inferior_ptid. */
4316 ptid_t curr_ptid
= get_current_thread (wait_status
);
4318 if (curr_ptid
!= null_ptid
)
4320 if (!remote_multi_process_p (rs
))
4325 /* Without this, some commands which require an active target
4326 (such as kill) won't work. This variable serves (at least)
4327 double duty as both the pid of the target process (if it has
4328 such), and as a flag indicating that a target is active. */
4329 curr_ptid
= magic_null_ptid
;
4333 remote_add_inferior (fake_pid_p
, curr_ptid
.pid (), -1, 1);
4335 /* Add the main thread and switch to it. Don't try reading
4336 registers yet, since we haven't fetched the target description
4338 thread_info
*tp
= add_thread_silent (curr_ptid
);
4339 switch_to_thread_no_regs (tp
);
4342 /* Print info about a thread that was found already stopped on
4346 print_one_stopped_thread (struct thread_info
*thread
)
4348 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
4350 switch_to_thread (thread
);
4351 thread
->suspend
.stop_pc
= get_frame_pc (get_current_frame ());
4352 set_current_sal_from_frame (get_current_frame ());
4354 thread
->suspend
.waitstatus_pending_p
= 0;
4356 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
4358 enum gdb_signal sig
= ws
->value
.sig
;
4360 if (signal_print_state (sig
))
4361 gdb::observers::signal_received
.notify (sig
);
4363 gdb::observers::normal_stop
.notify (NULL
, 1);
4366 /* Process all initial stop replies the remote side sent in response
4367 to the ? packet. These indicate threads that were already stopped
4368 on initial connection. We mark these threads as stopped and print
4369 their current frame before giving the user the prompt. */
4372 remote_target::process_initial_stop_replies (int from_tty
)
4374 int pending_stop_replies
= stop_reply_queue_length ();
4375 struct thread_info
*selected
= NULL
;
4376 struct thread_info
*lowest_stopped
= NULL
;
4377 struct thread_info
*first
= NULL
;
4379 /* Consume the initial pending events. */
4380 while (pending_stop_replies
-- > 0)
4382 ptid_t waiton_ptid
= minus_one_ptid
;
4384 struct target_waitstatus ws
;
4385 int ignore_event
= 0;
4387 memset (&ws
, 0, sizeof (ws
));
4388 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
4390 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
4394 case TARGET_WAITKIND_IGNORE
:
4395 case TARGET_WAITKIND_NO_RESUMED
:
4396 case TARGET_WAITKIND_SIGNALLED
:
4397 case TARGET_WAITKIND_EXITED
:
4398 /* We shouldn't see these, but if we do, just ignore. */
4400 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
4404 case TARGET_WAITKIND_EXECD
:
4405 xfree (ws
.value
.execd_pathname
);
4414 struct thread_info
*evthread
= find_thread_ptid (event_ptid
);
4416 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
4418 enum gdb_signal sig
= ws
.value
.sig
;
4420 /* Stubs traditionally report SIGTRAP as initial signal,
4421 instead of signal 0. Suppress it. */
4422 if (sig
== GDB_SIGNAL_TRAP
)
4424 evthread
->suspend
.stop_signal
= sig
;
4428 evthread
->suspend
.waitstatus
= ws
;
4430 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
4431 || ws
.value
.sig
!= GDB_SIGNAL_0
)
4432 evthread
->suspend
.waitstatus_pending_p
= 1;
4434 set_executing (event_ptid
, 0);
4435 set_running (event_ptid
, 0);
4436 get_remote_thread_info (evthread
)->vcont_resumed
= 0;
4439 /* "Notice" the new inferiors before anything related to
4440 registers/memory. */
4441 for (inferior
*inf
: all_non_exited_inferiors ())
4443 inf
->needs_setup
= 1;
4447 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4448 notice_new_inferior (thread
, thread
->state
== THREAD_RUNNING
,
4453 /* If all-stop on top of non-stop, pause all threads. Note this
4454 records the threads' stop pc, so must be done after "noticing"
4458 stop_all_threads ();
4460 /* If all threads of an inferior were already stopped, we
4461 haven't setup the inferior yet. */
4462 for (inferior
*inf
: all_non_exited_inferiors ())
4464 if (inf
->needs_setup
)
4466 thread_info
*thread
= any_live_thread_of_inferior (inf
);
4467 switch_to_thread_no_regs (thread
);
4473 /* Now go over all threads that are stopped, and print their current
4474 frame. If all-stop, then if there's a signalled thread, pick
4476 for (thread_info
*thread
: all_non_exited_threads ())
4482 thread
->set_running (false);
4483 else if (thread
->state
!= THREAD_STOPPED
)
4486 if (selected
== NULL
4487 && thread
->suspend
.waitstatus_pending_p
)
4490 if (lowest_stopped
== NULL
4491 || thread
->inf
->num
< lowest_stopped
->inf
->num
4492 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4493 lowest_stopped
= thread
;
4496 print_one_stopped_thread (thread
);
4499 /* In all-stop, we only print the status of one thread, and leave
4500 others with their status pending. */
4503 thread_info
*thread
= selected
;
4505 thread
= lowest_stopped
;
4509 print_one_stopped_thread (thread
);
4512 /* For "info program". */
4513 thread_info
*thread
= inferior_thread ();
4514 if (thread
->state
== THREAD_STOPPED
)
4515 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4518 /* Start the remote connection and sync state. */
4521 remote_target::start_remote (int from_tty
, int extended_p
)
4523 struct remote_state
*rs
= get_remote_state ();
4524 struct packet_config
*noack_config
;
4525 char *wait_status
= NULL
;
4527 /* Signal other parts that we're going through the initial setup,
4528 and so things may not be stable yet. E.g., we don't try to
4529 install tracepoints until we've relocated symbols. Also, a
4530 Ctrl-C before we're connected and synced up can't interrupt the
4531 target. Instead, it offers to drop the (potentially wedged)
4533 rs
->starting_up
= 1;
4537 if (interrupt_on_connect
)
4538 send_interrupt_sequence ();
4540 /* Ack any packet which the remote side has already sent. */
4541 remote_serial_write ("+", 1);
4543 /* The first packet we send to the target is the optional "supported
4544 packets" request. If the target can answer this, it will tell us
4545 which later probes to skip. */
4546 remote_query_supported ();
4548 /* If the stub wants to get a QAllow, compose one and send it. */
4549 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4552 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4553 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4554 as a reply to known packet. For packet "vFile:setfs:" it is an
4555 invalid reply and GDB would return error in
4556 remote_hostio_set_filesystem, making remote files access impossible.
4557 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4558 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4560 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4562 putpkt (v_mustreplyempty
);
4563 getpkt (&rs
->buf
, 0);
4564 if (strcmp (rs
->buf
.data (), "OK") == 0)
4565 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4566 else if (strcmp (rs
->buf
.data (), "") != 0)
4567 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4571 /* Next, we possibly activate noack mode.
4573 If the QStartNoAckMode packet configuration is set to AUTO,
4574 enable noack mode if the stub reported a wish for it with
4577 If set to TRUE, then enable noack mode even if the stub didn't
4578 report it in qSupported. If the stub doesn't reply OK, the
4579 session ends with an error.
4581 If FALSE, then don't activate noack mode, regardless of what the
4582 stub claimed should be the default with qSupported. */
4584 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4585 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4587 putpkt ("QStartNoAckMode");
4588 getpkt (&rs
->buf
, 0);
4589 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4595 /* Tell the remote that we are using the extended protocol. */
4597 getpkt (&rs
->buf
, 0);
4600 /* Let the target know which signals it is allowed to pass down to
4602 update_signals_program_target ();
4604 /* Next, if the target can specify a description, read it. We do
4605 this before anything involving memory or registers. */
4606 target_find_description ();
4608 /* Next, now that we know something about the target, update the
4609 address spaces in the program spaces. */
4610 update_address_spaces ();
4612 /* On OSs where the list of libraries is global to all
4613 processes, we fetch them early. */
4614 if (gdbarch_has_global_solist (target_gdbarch ()))
4615 solib_add (NULL
, from_tty
, auto_solib_add
);
4617 if (target_is_non_stop_p ())
4619 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4620 error (_("Non-stop mode requested, but remote "
4621 "does not support non-stop"));
4623 putpkt ("QNonStop:1");
4624 getpkt (&rs
->buf
, 0);
4626 if (strcmp (rs
->buf
.data (), "OK") != 0)
4627 error (_("Remote refused setting non-stop mode with: %s"),
4630 /* Find about threads and processes the stub is already
4631 controlling. We default to adding them in the running state.
4632 The '?' query below will then tell us about which threads are
4634 this->update_thread_list ();
4636 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4638 /* Don't assume that the stub can operate in all-stop mode.
4639 Request it explicitly. */
4640 putpkt ("QNonStop:0");
4641 getpkt (&rs
->buf
, 0);
4643 if (strcmp (rs
->buf
.data (), "OK") != 0)
4644 error (_("Remote refused setting all-stop mode with: %s"),
4648 /* Upload TSVs regardless of whether the target is running or not. The
4649 remote stub, such as GDBserver, may have some predefined or builtin
4650 TSVs, even if the target is not running. */
4651 if (get_trace_status (current_trace_status ()) != -1)
4653 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4655 upload_trace_state_variables (&uploaded_tsvs
);
4656 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4659 /* Check whether the target is running now. */
4661 getpkt (&rs
->buf
, 0);
4663 if (!target_is_non_stop_p ())
4665 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4668 error (_("The target is not running (try extended-remote?)"));
4670 /* We're connected, but not running. Drop out before we
4671 call start_remote. */
4672 rs
->starting_up
= 0;
4677 /* Save the reply for later. */
4678 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
4679 strcpy (wait_status
, rs
->buf
.data ());
4682 /* Fetch thread list. */
4683 target_update_thread_list ();
4685 /* Let the stub know that we want it to return the thread. */
4686 set_continue_thread (minus_one_ptid
);
4688 if (thread_count () == 0)
4690 /* Target has no concept of threads at all. GDB treats
4691 non-threaded target as single-threaded; add a main
4693 add_current_inferior_and_thread (wait_status
);
4697 /* We have thread information; select the thread the target
4698 says should be current. If we're reconnecting to a
4699 multi-threaded program, this will ideally be the thread
4700 that last reported an event before GDB disconnected. */
4701 inferior_ptid
= get_current_thread (wait_status
);
4702 if (inferior_ptid
== null_ptid
)
4704 /* Odd... The target was able to list threads, but not
4705 tell us which thread was current (no "thread"
4706 register in T stop reply?). Just pick the first
4707 thread in the thread list then. */
4710 fprintf_unfiltered (gdb_stdlog
,
4711 "warning: couldn't determine remote "
4712 "current thread; picking first in list.\n");
4714 inferior_ptid
= inferior_list
->thread_list
->ptid
;
4718 /* init_wait_for_inferior should be called before get_offsets in order
4719 to manage `inserted' flag in bp loc in a correct state.
4720 breakpoint_init_inferior, called from init_wait_for_inferior, set
4721 `inserted' flag to 0, while before breakpoint_re_set, called from
4722 start_remote, set `inserted' flag to 1. In the initialization of
4723 inferior, breakpoint_init_inferior should be called first, and then
4724 breakpoint_re_set can be called. If this order is broken, state of
4725 `inserted' flag is wrong, and cause some problems on breakpoint
4727 init_wait_for_inferior ();
4729 get_offsets (); /* Get text, data & bss offsets. */
4731 /* If we could not find a description using qXfer, and we know
4732 how to do it some other way, try again. This is not
4733 supported for non-stop; it could be, but it is tricky if
4734 there are no stopped threads when we connect. */
4735 if (remote_read_description_p (this)
4736 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4738 target_clear_description ();
4739 target_find_description ();
4742 /* Use the previously fetched status. */
4743 gdb_assert (wait_status
!= NULL
);
4744 strcpy (rs
->buf
.data (), wait_status
);
4745 rs
->cached_wait_status
= 1;
4747 ::start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4751 /* Clear WFI global state. Do this before finding about new
4752 threads and inferiors, and setting the current inferior.
4753 Otherwise we would clear the proceed status of the current
4754 inferior when we want its stop_soon state to be preserved
4755 (see notice_new_inferior). */
4756 init_wait_for_inferior ();
4758 /* In non-stop, we will either get an "OK", meaning that there
4759 are no stopped threads at this time; or, a regular stop
4760 reply. In the latter case, there may be more than one thread
4761 stopped --- we pull them all out using the vStopped
4763 if (strcmp (rs
->buf
.data (), "OK") != 0)
4765 struct notif_client
*notif
= ¬if_client_stop
;
4767 /* remote_notif_get_pending_replies acks this one, and gets
4769 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4770 = remote_notif_parse (this, notif
, rs
->buf
.data ());
4771 remote_notif_get_pending_events (notif
);
4774 if (thread_count () == 0)
4777 error (_("The target is not running (try extended-remote?)"));
4779 /* We're connected, but not running. Drop out before we
4780 call start_remote. */
4781 rs
->starting_up
= 0;
4785 /* In non-stop mode, any cached wait status will be stored in
4786 the stop reply queue. */
4787 gdb_assert (wait_status
== NULL
);
4789 /* Report all signals during attach/startup. */
4792 /* If there are already stopped threads, mark them stopped and
4793 report their stops before giving the prompt to the user. */
4794 process_initial_stop_replies (from_tty
);
4796 if (target_can_async_p ())
4800 /* If we connected to a live target, do some additional setup. */
4801 if (target_has_execution
)
4803 if (symfile_objfile
) /* No use without a symbol-file. */
4804 remote_check_symbols ();
4807 /* Possibly the target has been engaged in a trace run started
4808 previously; find out where things are at. */
4809 if (get_trace_status (current_trace_status ()) != -1)
4811 struct uploaded_tp
*uploaded_tps
= NULL
;
4813 if (current_trace_status ()->running
)
4814 printf_filtered (_("Trace is already running on the target.\n"));
4816 upload_tracepoints (&uploaded_tps
);
4818 merge_uploaded_tracepoints (&uploaded_tps
);
4821 /* Possibly the target has been engaged in a btrace record started
4822 previously; find out where things are at. */
4823 remote_btrace_maybe_reopen ();
4825 /* The thread and inferior lists are now synchronized with the
4826 target, our symbols have been relocated, and we're merged the
4827 target's tracepoints with ours. We're done with basic start
4829 rs
->starting_up
= 0;
4831 /* Maybe breakpoints are global and need to be inserted now. */
4832 if (breakpoints_should_be_inserted_now ())
4833 insert_breakpoints ();
4836 /* Open a connection to a remote debugger.
4837 NAME is the filename used for communication. */
4840 remote_target::open (const char *name
, int from_tty
)
4842 open_1 (name
, from_tty
, 0);
4845 /* Open a connection to a remote debugger using the extended
4846 remote gdb protocol. NAME is the filename used for communication. */
4849 extended_remote_target::open (const char *name
, int from_tty
)
4851 open_1 (name
, from_tty
, 1 /*extended_p */);
4854 /* Reset all packets back to "unknown support". Called when opening a
4855 new connection to a remote target. */
4858 reset_all_packet_configs_support (void)
4862 for (i
= 0; i
< PACKET_MAX
; i
++)
4863 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4866 /* Initialize all packet configs. */
4869 init_all_packet_configs (void)
4873 for (i
= 0; i
< PACKET_MAX
; i
++)
4875 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4876 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4880 /* Symbol look-up. */
4883 remote_target::remote_check_symbols ()
4888 /* The remote side has no concept of inferiors that aren't running
4889 yet, it only knows about running processes. If we're connected
4890 but our current inferior is not running, we should not invite the
4891 remote target to request symbol lookups related to its
4892 (unrelated) current process. */
4893 if (!target_has_execution
)
4896 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4899 /* Make sure the remote is pointing at the right process. Note
4900 there's no way to select "no process". */
4901 set_general_process ();
4903 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4904 because we need both at the same time. */
4905 gdb::char_vector
msg (get_remote_packet_size ());
4906 gdb::char_vector
reply (get_remote_packet_size ());
4908 /* Invite target to request symbol lookups. */
4910 putpkt ("qSymbol::");
4912 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4914 while (startswith (reply
.data (), "qSymbol:"))
4916 struct bound_minimal_symbol sym
;
4919 end
= hex2bin (tmp
, reinterpret_cast <gdb_byte
*> (msg
.data ()),
4922 sym
= lookup_minimal_symbol (msg
.data (), NULL
, NULL
);
4923 if (sym
.minsym
== NULL
)
4924 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol::%s",
4928 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4929 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4931 /* If this is a function address, return the start of code
4932 instead of any data function descriptor. */
4933 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4935 current_top_target ());
4937 xsnprintf (msg
.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4938 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4941 putpkt (msg
.data ());
4946 static struct serial
*
4947 remote_serial_open (const char *name
)
4949 static int udp_warning
= 0;
4951 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4952 of in ser-tcp.c, because it is the remote protocol assuming that the
4953 serial connection is reliable and not the serial connection promising
4955 if (!udp_warning
&& startswith (name
, "udp:"))
4957 warning (_("The remote protocol may be unreliable over UDP.\n"
4958 "Some events may be lost, rendering further debugging "
4963 return serial_open (name
);
4966 /* Inform the target of our permission settings. The permission flags
4967 work without this, but if the target knows the settings, it can do
4968 a couple things. First, it can add its own check, to catch cases
4969 that somehow manage to get by the permissions checks in target
4970 methods. Second, if the target is wired to disallow particular
4971 settings (for instance, a system in the field that is not set up to
4972 be able to stop at a breakpoint), it can object to any unavailable
4976 remote_target::set_permissions ()
4978 struct remote_state
*rs
= get_remote_state ();
4980 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAllow:"
4981 "WriteReg:%x;WriteMem:%x;"
4982 "InsertBreak:%x;InsertTrace:%x;"
4983 "InsertFastTrace:%x;Stop:%x",
4984 may_write_registers
, may_write_memory
,
4985 may_insert_breakpoints
, may_insert_tracepoints
,
4986 may_insert_fast_tracepoints
, may_stop
);
4988 getpkt (&rs
->buf
, 0);
4990 /* If the target didn't like the packet, warn the user. Do not try
4991 to undo the user's settings, that would just be maddening. */
4992 if (strcmp (rs
->buf
.data (), "OK") != 0)
4993 warning (_("Remote refused setting permissions with: %s"),
4997 /* This type describes each known response to the qSupported
4999 struct protocol_feature
5001 /* The name of this protocol feature. */
5004 /* The default for this protocol feature. */
5005 enum packet_support default_support
;
5007 /* The function to call when this feature is reported, or after
5008 qSupported processing if the feature is not supported.
5009 The first argument points to this structure. The second
5010 argument indicates whether the packet requested support be
5011 enabled, disabled, or probed (or the default, if this function
5012 is being called at the end of processing and this feature was
5013 not reported). The third argument may be NULL; if not NULL, it
5014 is a NUL-terminated string taken from the packet following
5015 this feature's name and an equals sign. */
5016 void (*func
) (remote_target
*remote
, const struct protocol_feature
*,
5017 enum packet_support
, const char *);
5019 /* The corresponding packet for this feature. Only used if
5020 FUNC is remote_supported_packet. */
5025 remote_supported_packet (remote_target
*remote
,
5026 const struct protocol_feature
*feature
,
5027 enum packet_support support
,
5028 const char *argument
)
5032 warning (_("Remote qSupported response supplied an unexpected value for"
5033 " \"%s\"."), feature
->name
);
5037 remote_protocol_packets
[feature
->packet
].support
= support
;
5041 remote_target::remote_packet_size (const protocol_feature
*feature
,
5042 enum packet_support support
, const char *value
)
5044 struct remote_state
*rs
= get_remote_state ();
5049 if (support
!= PACKET_ENABLE
)
5052 if (value
== NULL
|| *value
== '\0')
5054 warning (_("Remote target reported \"%s\" without a size."),
5060 packet_size
= strtol (value
, &value_end
, 16);
5061 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
5063 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5064 feature
->name
, value
);
5068 /* Record the new maximum packet size. */
5069 rs
->explicit_packet_size
= packet_size
;
5073 remote_packet_size (remote_target
*remote
, const protocol_feature
*feature
,
5074 enum packet_support support
, const char *value
)
5076 remote
->remote_packet_size (feature
, support
, value
);
5079 static const struct protocol_feature remote_protocol_features
[] = {
5080 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
5081 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
5082 PACKET_qXfer_auxv
},
5083 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
5084 PACKET_qXfer_exec_file
},
5085 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
5086 PACKET_qXfer_features
},
5087 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
5088 PACKET_qXfer_libraries
},
5089 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
5090 PACKET_qXfer_libraries_svr4
},
5091 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
5092 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
5093 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
5094 PACKET_qXfer_memory_map
},
5095 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
5096 PACKET_qXfer_spu_read
},
5097 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
5098 PACKET_qXfer_spu_write
},
5099 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
5100 PACKET_qXfer_osdata
},
5101 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
5102 PACKET_qXfer_threads
},
5103 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
5104 PACKET_qXfer_traceframe_info
},
5105 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
5106 PACKET_QPassSignals
},
5107 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
5108 PACKET_QCatchSyscalls
},
5109 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
5110 PACKET_QProgramSignals
},
5111 { "QSetWorkingDir", PACKET_DISABLE
, remote_supported_packet
,
5112 PACKET_QSetWorkingDir
},
5113 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
5114 PACKET_QStartupWithShell
},
5115 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
5116 PACKET_QEnvironmentHexEncoded
},
5117 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
5118 PACKET_QEnvironmentReset
},
5119 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
5120 PACKET_QEnvironmentUnset
},
5121 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
5122 PACKET_QStartNoAckMode
},
5123 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
5124 PACKET_multiprocess_feature
},
5125 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
5126 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
5127 PACKET_qXfer_siginfo_read
},
5128 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
5129 PACKET_qXfer_siginfo_write
},
5130 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5131 PACKET_ConditionalTracepoints
},
5132 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
5133 PACKET_ConditionalBreakpoints
},
5134 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
5135 PACKET_BreakpointCommands
},
5136 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5137 PACKET_FastTracepoints
},
5138 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5139 PACKET_StaticTracepoints
},
5140 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
5141 PACKET_InstallInTrace
},
5142 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
5143 PACKET_DisconnectedTracing_feature
},
5144 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
5146 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
5148 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
5149 PACKET_TracepointSource
},
5150 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
5152 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
5153 PACKET_EnableDisableTracepoints_feature
},
5154 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
5155 PACKET_qXfer_fdpic
},
5156 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
5158 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
5159 PACKET_QDisableRandomization
},
5160 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
5161 { "QTBuffer:size", PACKET_DISABLE
,
5162 remote_supported_packet
, PACKET_QTBuffer_size
},
5163 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
5164 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
5165 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
5166 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
5167 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
5168 PACKET_qXfer_btrace
},
5169 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
5170 PACKET_qXfer_btrace_conf
},
5171 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
5172 PACKET_Qbtrace_conf_bts_size
},
5173 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
5174 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
5175 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
5176 PACKET_fork_event_feature
},
5177 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
5178 PACKET_vfork_event_feature
},
5179 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
5180 PACKET_exec_event_feature
},
5181 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
5182 PACKET_Qbtrace_conf_pt_size
},
5183 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
5184 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
5185 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
5188 static char *remote_support_xml
;
5190 /* Register string appended to "xmlRegisters=" in qSupported query. */
5193 register_remote_support_xml (const char *xml
)
5195 #if defined(HAVE_LIBEXPAT)
5196 if (remote_support_xml
== NULL
)
5197 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
5200 char *copy
= xstrdup (remote_support_xml
+ 13);
5201 char *p
= strtok (copy
, ",");
5205 if (strcmp (p
, xml
) == 0)
5212 while ((p
= strtok (NULL
, ",")) != NULL
);
5215 remote_support_xml
= reconcat (remote_support_xml
,
5216 remote_support_xml
, ",", xml
,
5223 remote_query_supported_append (std::string
*msg
, const char *append
)
5227 msg
->append (append
);
5231 remote_target::remote_query_supported ()
5233 struct remote_state
*rs
= get_remote_state ();
5236 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
5238 /* The packet support flags are handled differently for this packet
5239 than for most others. We treat an error, a disabled packet, and
5240 an empty response identically: any features which must be reported
5241 to be used will be automatically disabled. An empty buffer
5242 accomplishes this, since that is also the representation for a list
5243 containing no features. */
5246 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
5250 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
5251 remote_query_supported_append (&q
, "multiprocess+");
5253 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5254 remote_query_supported_append (&q
, "swbreak+");
5255 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
5256 remote_query_supported_append (&q
, "hwbreak+");
5258 remote_query_supported_append (&q
, "qRelocInsn+");
5260 if (packet_set_cmd_state (PACKET_fork_event_feature
)
5261 != AUTO_BOOLEAN_FALSE
)
5262 remote_query_supported_append (&q
, "fork-events+");
5263 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
5264 != AUTO_BOOLEAN_FALSE
)
5265 remote_query_supported_append (&q
, "vfork-events+");
5266 if (packet_set_cmd_state (PACKET_exec_event_feature
)
5267 != AUTO_BOOLEAN_FALSE
)
5268 remote_query_supported_append (&q
, "exec-events+");
5270 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
5271 remote_query_supported_append (&q
, "vContSupported+");
5273 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
5274 remote_query_supported_append (&q
, "QThreadEvents+");
5276 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
5277 remote_query_supported_append (&q
, "no-resumed+");
5279 /* Keep this one last to work around a gdbserver <= 7.10 bug in
5280 the qSupported:xmlRegisters=i386 handling. */
5281 if (remote_support_xml
!= NULL
5282 && packet_support (PACKET_qXfer_features
) != PACKET_DISABLE
)
5283 remote_query_supported_append (&q
, remote_support_xml
);
5285 q
= "qSupported:" + q
;
5286 putpkt (q
.c_str ());
5288 getpkt (&rs
->buf
, 0);
5290 /* If an error occured, warn, but do not return - just reset the
5291 buffer to empty and go on to disable features. */
5292 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
5295 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
5300 memset (seen
, 0, sizeof (seen
));
5302 next
= rs
->buf
.data ();
5305 enum packet_support is_supported
;
5306 char *p
, *end
, *name_end
, *value
;
5308 /* First separate out this item from the rest of the packet. If
5309 there's another item after this, we overwrite the separator
5310 (terminated strings are much easier to work with). */
5312 end
= strchr (p
, ';');
5315 end
= p
+ strlen (p
);
5325 warning (_("empty item in \"qSupported\" response"));
5330 name_end
= strchr (p
, '=');
5333 /* This is a name=value entry. */
5334 is_supported
= PACKET_ENABLE
;
5335 value
= name_end
+ 1;
5344 is_supported
= PACKET_ENABLE
;
5348 is_supported
= PACKET_DISABLE
;
5352 is_supported
= PACKET_SUPPORT_UNKNOWN
;
5356 warning (_("unrecognized item \"%s\" "
5357 "in \"qSupported\" response"), p
);
5363 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5364 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
5366 const struct protocol_feature
*feature
;
5369 feature
= &remote_protocol_features
[i
];
5370 feature
->func (this, feature
, is_supported
, value
);
5375 /* If we increased the packet size, make sure to increase the global
5376 buffer size also. We delay this until after parsing the entire
5377 qSupported packet, because this is the same buffer we were
5379 if (rs
->buf
.size () < rs
->explicit_packet_size
)
5380 rs
->buf
.resize (rs
->explicit_packet_size
);
5382 /* Handle the defaults for unmentioned features. */
5383 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
5386 const struct protocol_feature
*feature
;
5388 feature
= &remote_protocol_features
[i
];
5389 feature
->func (this, feature
, feature
->default_support
, NULL
);
5393 /* Serial QUIT handler for the remote serial descriptor.
5395 Defers handling a Ctrl-C until we're done with the current
5396 command/response packet sequence, unless:
5398 - We're setting up the connection. Don't send a remote interrupt
5399 request, as we're not fully synced yet. Quit immediately
5402 - The target has been resumed in the foreground
5403 (target_terminal::is_ours is false) with a synchronous resume
5404 packet, and we're blocked waiting for the stop reply, thus a
5405 Ctrl-C should be immediately sent to the target.
5407 - We get a second Ctrl-C while still within the same serial read or
5408 write. In that case the serial is seemingly wedged --- offer to
5411 - We see a second Ctrl-C without target response, after having
5412 previously interrupted the target. In that case the target/stub
5413 is probably wedged --- offer to quit/disconnect.
5417 remote_target::remote_serial_quit_handler ()
5419 struct remote_state
*rs
= get_remote_state ();
5421 if (check_quit_flag ())
5423 /* If we're starting up, we're not fully synced yet. Quit
5425 if (rs
->starting_up
)
5427 else if (rs
->got_ctrlc_during_io
)
5429 if (query (_("The target is not responding to GDB commands.\n"
5430 "Stop debugging it? ")))
5431 remote_unpush_and_throw ();
5433 /* If ^C has already been sent once, offer to disconnect. */
5434 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
5436 /* All-stop protocol, and blocked waiting for stop reply. Send
5437 an interrupt request. */
5438 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
5439 target_interrupt ();
5441 rs
->got_ctrlc_during_io
= 1;
5445 /* The remote_target that is current while the quit handler is
5446 overridden with remote_serial_quit_handler. */
5447 static remote_target
*curr_quit_handler_target
;
5450 remote_serial_quit_handler ()
5452 curr_quit_handler_target
->remote_serial_quit_handler ();
5455 /* Remove any of the remote.c targets from target stack. Upper targets depend
5456 on it so remove them first. */
5459 remote_unpush_target (void)
5461 pop_all_targets_at_and_above (process_stratum
);
5465 remote_unpush_and_throw (void)
5467 remote_unpush_target ();
5468 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5472 remote_target::open_1 (const char *name
, int from_tty
, int extended_p
)
5474 remote_target
*curr_remote
= get_current_remote_target ();
5477 error (_("To open a remote debug connection, you need to specify what\n"
5478 "serial device is attached to the remote system\n"
5479 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5481 /* If we're connected to a running target, target_preopen will kill it.
5482 Ask this question first, before target_preopen has a chance to kill
5484 if (curr_remote
!= NULL
&& !have_inferiors ())
5487 && !query (_("Already connected to a remote target. Disconnect? ")))
5488 error (_("Still connected."));
5491 /* Here the possibly existing remote target gets unpushed. */
5492 target_preopen (from_tty
);
5494 remote_fileio_reset ();
5495 reopen_exec_file ();
5498 remote_target
*remote
5499 = (extended_p
? new extended_remote_target () : new remote_target ());
5500 target_ops_up
target_holder (remote
);
5502 remote_state
*rs
= remote
->get_remote_state ();
5504 /* See FIXME above. */
5505 if (!target_async_permitted
)
5506 rs
->wait_forever_enabled_p
= 1;
5508 rs
->remote_desc
= remote_serial_open (name
);
5509 if (!rs
->remote_desc
)
5510 perror_with_name (name
);
5512 if (baud_rate
!= -1)
5514 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5516 /* The requested speed could not be set. Error out to
5517 top level after closing remote_desc. Take care to
5518 set remote_desc to NULL to avoid closing remote_desc
5520 serial_close (rs
->remote_desc
);
5521 rs
->remote_desc
= NULL
;
5522 perror_with_name (name
);
5526 serial_setparity (rs
->remote_desc
, serial_parity
);
5527 serial_raw (rs
->remote_desc
);
5529 /* If there is something sitting in the buffer we might take it as a
5530 response to a command, which would be bad. */
5531 serial_flush_input (rs
->remote_desc
);
5535 puts_filtered ("Remote debugging using ");
5536 puts_filtered (name
);
5537 puts_filtered ("\n");
5540 /* Switch to using the remote target now. */
5541 push_target (std::move (target_holder
));
5543 /* Register extra event sources in the event loop. */
5544 rs
->remote_async_inferior_event_token
5545 = create_async_event_handler (remote_async_inferior_event_handler
,
5547 rs
->notif_state
= remote_notif_state_allocate (remote
);
5549 /* Reset the target state; these things will be queried either by
5550 remote_query_supported or as they are needed. */
5551 reset_all_packet_configs_support ();
5552 rs
->cached_wait_status
= 0;
5553 rs
->explicit_packet_size
= 0;
5555 rs
->extended
= extended_p
;
5556 rs
->waiting_for_stop_reply
= 0;
5557 rs
->ctrlc_pending_p
= 0;
5558 rs
->got_ctrlc_during_io
= 0;
5560 rs
->general_thread
= not_sent_ptid
;
5561 rs
->continue_thread
= not_sent_ptid
;
5562 rs
->remote_traceframe_number
= -1;
5564 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5566 /* Probe for ability to use "ThreadInfo" query, as required. */
5567 rs
->use_threadinfo_query
= 1;
5568 rs
->use_threadextra_query
= 1;
5570 rs
->readahead_cache
.invalidate ();
5572 if (target_async_permitted
)
5574 /* FIXME: cagney/1999-09-23: During the initial connection it is
5575 assumed that the target is already ready and able to respond to
5576 requests. Unfortunately remote_start_remote() eventually calls
5577 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5578 around this. Eventually a mechanism that allows
5579 wait_for_inferior() to expect/get timeouts will be
5581 rs
->wait_forever_enabled_p
= 0;
5584 /* First delete any symbols previously loaded from shared libraries. */
5585 no_shared_libraries (NULL
, 0);
5587 /* Start the remote connection. If error() or QUIT, discard this
5588 target (we'd otherwise be in an inconsistent state) and then
5589 propogate the error on up the exception chain. This ensures that
5590 the caller doesn't stumble along blindly assuming that the
5591 function succeeded. The CLI doesn't have this problem but other
5592 UI's, such as MI do.
5594 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5595 this function should return an error indication letting the
5596 caller restore the previous state. Unfortunately the command
5597 ``target remote'' is directly wired to this function making that
5598 impossible. On a positive note, the CLI side of this problem has
5599 been fixed - the function set_cmd_context() makes it possible for
5600 all the ``target ....'' commands to share a common callback
5601 function. See cli-dump.c. */
5606 remote
->start_remote (from_tty
, extended_p
);
5608 catch (const gdb_exception
&ex
)
5610 /* Pop the partially set up target - unless something else did
5611 already before throwing the exception. */
5612 if (ex
.error
!= TARGET_CLOSE_ERROR
)
5613 remote_unpush_target ();
5618 remote_btrace_reset (rs
);
5620 if (target_async_permitted
)
5621 rs
->wait_forever_enabled_p
= 1;
5624 /* Detach the specified process. */
5627 remote_target::remote_detach_pid (int pid
)
5629 struct remote_state
*rs
= get_remote_state ();
5631 /* This should not be necessary, but the handling for D;PID in
5632 GDBserver versions prior to 8.2 incorrectly assumes that the
5633 selected process points to the same process we're detaching,
5634 leading to misbehavior (and possibly GDBserver crashing) when it
5635 does not. Since it's easy and cheap, work around it by forcing
5636 GDBserver to select GDB's current process. */
5637 set_general_process ();
5639 if (remote_multi_process_p (rs
))
5640 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "D;%x", pid
);
5642 strcpy (rs
->buf
.data (), "D");
5645 getpkt (&rs
->buf
, 0);
5647 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5649 else if (rs
->buf
[0] == '\0')
5650 error (_("Remote doesn't know how to detach"));
5652 error (_("Can't detach process."));
5655 /* This detaches a program to which we previously attached, using
5656 inferior_ptid to identify the process. After this is done, GDB
5657 can be used to debug some other program. We better not have left
5658 any breakpoints in the target program or it'll die when it hits
5662 remote_target::remote_detach_1 (inferior
*inf
, int from_tty
)
5664 int pid
= inferior_ptid
.pid ();
5665 struct remote_state
*rs
= get_remote_state ();
5668 if (!target_has_execution
)
5669 error (_("No process to detach from."));
5671 target_announce_detach (from_tty
);
5673 /* Tell the remote target to detach. */
5674 remote_detach_pid (pid
);
5676 /* Exit only if this is the only active inferior. */
5677 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5678 puts_filtered (_("Ending remote debugging.\n"));
5680 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5682 /* Check to see if we are detaching a fork parent. Note that if we
5683 are detaching a fork child, tp == NULL. */
5684 is_fork_parent
= (tp
!= NULL
5685 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5687 /* If doing detach-on-fork, we don't mourn, because that will delete
5688 breakpoints that should be available for the followed inferior. */
5689 if (!is_fork_parent
)
5691 /* Save the pid as a string before mourning, since that will
5692 unpush the remote target, and we need the string after. */
5693 std::string infpid
= target_pid_to_str (ptid_t (pid
));
5695 target_mourn_inferior (inferior_ptid
);
5696 if (print_inferior_events
)
5697 printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5698 inf
->num
, infpid
.c_str ());
5702 inferior_ptid
= null_ptid
;
5703 detach_inferior (current_inferior ());
5708 remote_target::detach (inferior
*inf
, int from_tty
)
5710 remote_detach_1 (inf
, from_tty
);
5714 extended_remote_target::detach (inferior
*inf
, int from_tty
)
5716 remote_detach_1 (inf
, from_tty
);
5719 /* Target follow-fork function for remote targets. On entry, and
5720 at return, the current inferior is the fork parent.
5722 Note that although this is currently only used for extended-remote,
5723 it is named remote_follow_fork in anticipation of using it for the
5724 remote target as well. */
5727 remote_target::follow_fork (int follow_child
, int detach_fork
)
5729 struct remote_state
*rs
= get_remote_state ();
5730 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5732 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5733 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5735 /* When following the parent and detaching the child, we detach
5736 the child here. For the case of following the child and
5737 detaching the parent, the detach is done in the target-
5738 independent follow fork code in infrun.c. We can't use
5739 target_detach when detaching an unfollowed child because
5740 the client side doesn't know anything about the child. */
5741 if (detach_fork
&& !follow_child
)
5743 /* Detach the fork child. */
5747 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5748 child_pid
= child_ptid
.pid ();
5750 remote_detach_pid (child_pid
);
5756 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5757 in the program space of the new inferior. On entry and at return the
5758 current inferior is the exec'ing inferior. INF is the new exec'd
5759 inferior, which may be the same as the exec'ing inferior unless
5760 follow-exec-mode is "new". */
5763 remote_target::follow_exec (struct inferior
*inf
, char *execd_pathname
)
5765 /* We know that this is a target file name, so if it has the "target:"
5766 prefix we strip it off before saving it in the program space. */
5767 if (is_target_filename (execd_pathname
))
5768 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5770 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5773 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5776 remote_target::disconnect (const char *args
, int from_tty
)
5779 error (_("Argument given to \"disconnect\" when remotely debugging."));
5781 /* Make sure we unpush even the extended remote targets. Calling
5782 target_mourn_inferior won't unpush, and remote_mourn won't
5783 unpush if there is more than one inferior left. */
5784 unpush_target (this);
5785 generic_mourn_inferior ();
5788 puts_filtered ("Ending remote debugging.\n");
5791 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5792 be chatty about it. */
5795 extended_remote_target::attach (const char *args
, int from_tty
)
5797 struct remote_state
*rs
= get_remote_state ();
5799 char *wait_status
= NULL
;
5801 pid
= parse_pid_to_attach (args
);
5803 /* Remote PID can be freely equal to getpid, do not check it here the same
5804 way as in other targets. */
5806 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5807 error (_("This target does not support attaching to a process"));
5811 char *exec_file
= get_exec_file (0);
5814 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5815 target_pid_to_str (ptid_t (pid
)).c_str ());
5817 printf_unfiltered (_("Attaching to %s\n"),
5818 target_pid_to_str (ptid_t (pid
)).c_str ());
5821 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vAttach;%x", pid
);
5823 getpkt (&rs
->buf
, 0);
5825 switch (packet_ok (rs
->buf
,
5826 &remote_protocol_packets
[PACKET_vAttach
]))
5829 if (!target_is_non_stop_p ())
5831 /* Save the reply for later. */
5832 wait_status
= (char *) alloca (strlen (rs
->buf
.data ()) + 1);
5833 strcpy (wait_status
, rs
->buf
.data ());
5835 else if (strcmp (rs
->buf
.data (), "OK") != 0)
5836 error (_("Attaching to %s failed with: %s"),
5837 target_pid_to_str (ptid_t (pid
)).c_str (),
5840 case PACKET_UNKNOWN
:
5841 error (_("This target does not support attaching to a process"));
5843 error (_("Attaching to %s failed"),
5844 target_pid_to_str (ptid_t (pid
)).c_str ());
5847 set_current_inferior (remote_add_inferior (0, pid
, 1, 0));
5849 inferior_ptid
= ptid_t (pid
);
5851 if (target_is_non_stop_p ())
5853 struct thread_info
*thread
;
5855 /* Get list of threads. */
5856 update_thread_list ();
5858 thread
= first_thread_of_inferior (current_inferior ());
5860 inferior_ptid
= thread
->ptid
;
5862 inferior_ptid
= ptid_t (pid
);
5864 /* Invalidate our notion of the remote current thread. */
5865 record_currthread (rs
, minus_one_ptid
);
5869 /* Now, if we have thread information, update inferior_ptid. */
5870 inferior_ptid
= remote_current_thread (inferior_ptid
);
5872 /* Add the main thread to the thread list. */
5873 thread_info
*thr
= add_thread_silent (inferior_ptid
);
5874 /* Don't consider the thread stopped until we've processed the
5875 saved stop reply. */
5876 set_executing (thr
->ptid
, true);
5879 /* Next, if the target can specify a description, read it. We do
5880 this before anything involving memory or registers. */
5881 target_find_description ();
5883 if (!target_is_non_stop_p ())
5885 /* Use the previously fetched status. */
5886 gdb_assert (wait_status
!= NULL
);
5888 if (target_can_async_p ())
5890 struct notif_event
*reply
5891 = remote_notif_parse (this, ¬if_client_stop
, wait_status
);
5893 push_stop_reply ((struct stop_reply
*) reply
);
5899 gdb_assert (wait_status
!= NULL
);
5900 strcpy (rs
->buf
.data (), wait_status
);
5901 rs
->cached_wait_status
= 1;
5905 gdb_assert (wait_status
== NULL
);
5908 /* Implementation of the to_post_attach method. */
5911 extended_remote_target::post_attach (int pid
)
5913 /* Get text, data & bss offsets. */
5916 /* In certain cases GDB might not have had the chance to start
5917 symbol lookup up until now. This could happen if the debugged
5918 binary is not using shared libraries, the vsyscall page is not
5919 present (on Linux) and the binary itself hadn't changed since the
5920 debugging process was started. */
5921 if (symfile_objfile
!= NULL
)
5922 remote_check_symbols();
5926 /* Check for the availability of vCont. This function should also check
5930 remote_target::remote_vcont_probe ()
5932 remote_state
*rs
= get_remote_state ();
5935 strcpy (rs
->buf
.data (), "vCont?");
5937 getpkt (&rs
->buf
, 0);
5938 buf
= rs
->buf
.data ();
5940 /* Make sure that the features we assume are supported. */
5941 if (startswith (buf
, "vCont"))
5944 int support_c
, support_C
;
5946 rs
->supports_vCont
.s
= 0;
5947 rs
->supports_vCont
.S
= 0;
5950 rs
->supports_vCont
.t
= 0;
5951 rs
->supports_vCont
.r
= 0;
5952 while (p
&& *p
== ';')
5955 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5956 rs
->supports_vCont
.s
= 1;
5957 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5958 rs
->supports_vCont
.S
= 1;
5959 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5961 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5963 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5964 rs
->supports_vCont
.t
= 1;
5965 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5966 rs
->supports_vCont
.r
= 1;
5968 p
= strchr (p
, ';');
5971 /* If c, and C are not all supported, we can't use vCont. Clearing
5972 BUF will make packet_ok disable the packet. */
5973 if (!support_c
|| !support_C
)
5977 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCont
]);
5980 /* Helper function for building "vCont" resumptions. Write a
5981 resumption to P. ENDP points to one-passed-the-end of the buffer
5982 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5983 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5984 resumed thread should be single-stepped and/or signalled. If PTID
5985 equals minus_one_ptid, then all threads are resumed; if PTID
5986 represents a process, then all threads of the process are resumed;
5987 the thread to be stepped and/or signalled is given in the global
5991 remote_target::append_resumption (char *p
, char *endp
,
5992 ptid_t ptid
, int step
, gdb_signal siggnal
)
5994 struct remote_state
*rs
= get_remote_state ();
5996 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5997 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5999 /* GDB is willing to range step. */
6000 && use_range_stepping
6001 /* Target supports range stepping. */
6002 && rs
->supports_vCont
.r
6003 /* We don't currently support range stepping multiple
6004 threads with a wildcard (though the protocol allows it,
6005 so stubs shouldn't make an active effort to forbid
6007 && !(remote_multi_process_p (rs
) && ptid
.is_pid ()))
6009 struct thread_info
*tp
;
6011 if (ptid
== minus_one_ptid
)
6013 /* If we don't know about the target thread's tid, then
6014 we're resuming magic_null_ptid (see caller). */
6015 tp
= find_thread_ptid (magic_null_ptid
);
6018 tp
= find_thread_ptid (ptid
);
6019 gdb_assert (tp
!= NULL
);
6021 if (tp
->control
.may_range_step
)
6023 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
6025 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
6026 phex_nz (tp
->control
.step_range_start
,
6028 phex_nz (tp
->control
.step_range_end
,
6032 p
+= xsnprintf (p
, endp
- p
, ";s");
6035 p
+= xsnprintf (p
, endp
- p
, ";s");
6036 else if (siggnal
!= GDB_SIGNAL_0
)
6037 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
6039 p
+= xsnprintf (p
, endp
- p
, ";c");
6041 if (remote_multi_process_p (rs
) && ptid
.is_pid ())
6045 /* All (-1) threads of process. */
6046 nptid
= ptid_t (ptid
.pid (), -1, 0);
6048 p
+= xsnprintf (p
, endp
- p
, ":");
6049 p
= write_ptid (p
, endp
, nptid
);
6051 else if (ptid
!= minus_one_ptid
)
6053 p
+= xsnprintf (p
, endp
- p
, ":");
6054 p
= write_ptid (p
, endp
, ptid
);
6060 /* Clear the thread's private info on resume. */
6063 resume_clear_thread_private_info (struct thread_info
*thread
)
6065 if (thread
->priv
!= NULL
)
6067 remote_thread_info
*priv
= get_remote_thread_info (thread
);
6069 priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6070 priv
->watch_data_address
= 0;
6074 /* Append a vCont continue-with-signal action for threads that have a
6075 non-zero stop signal. */
6078 remote_target::append_pending_thread_resumptions (char *p
, char *endp
,
6081 for (thread_info
*thread
: all_non_exited_threads (ptid
))
6082 if (inferior_ptid
!= thread
->ptid
6083 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
6085 p
= append_resumption (p
, endp
, thread
->ptid
,
6086 0, thread
->suspend
.stop_signal
);
6087 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
6088 resume_clear_thread_private_info (thread
);
6094 /* Set the target running, using the packets that use Hc
6098 remote_target::remote_resume_with_hc (ptid_t ptid
, int step
,
6101 struct remote_state
*rs
= get_remote_state ();
6104 rs
->last_sent_signal
= siggnal
;
6105 rs
->last_sent_step
= step
;
6107 /* The c/s/C/S resume packets use Hc, so set the continue
6109 if (ptid
== minus_one_ptid
)
6110 set_continue_thread (any_thread_ptid
);
6112 set_continue_thread (ptid
);
6114 for (thread_info
*thread
: all_non_exited_threads ())
6115 resume_clear_thread_private_info (thread
);
6117 buf
= rs
->buf
.data ();
6118 if (::execution_direction
== EXEC_REVERSE
)
6120 /* We don't pass signals to the target in reverse exec mode. */
6121 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
6122 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6125 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
6126 error (_("Remote reverse-step not supported."));
6127 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
6128 error (_("Remote reverse-continue not supported."));
6130 strcpy (buf
, step
? "bs" : "bc");
6132 else if (siggnal
!= GDB_SIGNAL_0
)
6134 buf
[0] = step
? 'S' : 'C';
6135 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
6136 buf
[2] = tohex (((int) siggnal
) & 0xf);
6140 strcpy (buf
, step
? "s" : "c");
6145 /* Resume the remote inferior by using a "vCont" packet. The thread
6146 to be resumed is PTID; STEP and SIGGNAL indicate whether the
6147 resumed thread should be single-stepped and/or signalled. If PTID
6148 equals minus_one_ptid, then all threads are resumed; the thread to
6149 be stepped and/or signalled is given in the global INFERIOR_PTID.
6150 This function returns non-zero iff it resumes the inferior.
6152 This function issues a strict subset of all possible vCont commands
6156 remote_target::remote_resume_with_vcont (ptid_t ptid
, int step
,
6157 enum gdb_signal siggnal
)
6159 struct remote_state
*rs
= get_remote_state ();
6163 /* No reverse execution actions defined for vCont. */
6164 if (::execution_direction
== EXEC_REVERSE
)
6167 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6168 remote_vcont_probe ();
6170 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
6173 p
= rs
->buf
.data ();
6174 endp
= p
+ get_remote_packet_size ();
6176 /* If we could generate a wider range of packets, we'd have to worry
6177 about overflowing BUF. Should there be a generic
6178 "multi-part-packet" packet? */
6180 p
+= xsnprintf (p
, endp
- p
, "vCont");
6182 if (ptid
== magic_null_ptid
)
6184 /* MAGIC_NULL_PTID means that we don't have any active threads,
6185 so we don't have any TID numbers the inferior will
6186 understand. Make sure to only send forms that do not specify
6188 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
6190 else if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
6192 /* Resume all threads (of all processes, or of a single
6193 process), with preference for INFERIOR_PTID. This assumes
6194 inferior_ptid belongs to the set of all threads we are about
6196 if (step
|| siggnal
!= GDB_SIGNAL_0
)
6198 /* Step inferior_ptid, with or without signal. */
6199 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
6202 /* Also pass down any pending signaled resumption for other
6203 threads not the current. */
6204 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
6206 /* And continue others without a signal. */
6207 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
6211 /* Scheduler locking; resume only PTID. */
6212 append_resumption (p
, endp
, ptid
, step
, siggnal
);
6215 gdb_assert (strlen (rs
->buf
.data ()) < get_remote_packet_size ());
6218 if (target_is_non_stop_p ())
6220 /* In non-stop, the stub replies to vCont with "OK". The stop
6221 reply will be reported asynchronously by means of a `%Stop'
6223 getpkt (&rs
->buf
, 0);
6224 if (strcmp (rs
->buf
.data (), "OK") != 0)
6225 error (_("Unexpected vCont reply in non-stop mode: %s"),
6232 /* Tell the remote machine to resume. */
6235 remote_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
6237 struct remote_state
*rs
= get_remote_state ();
6239 /* When connected in non-stop mode, the core resumes threads
6240 individually. Resuming remote threads directly in target_resume
6241 would thus result in sending one packet per thread. Instead, to
6242 minimize roundtrip latency, here we just store the resume
6243 request; the actual remote resumption will be done in
6244 target_commit_resume / remote_commit_resume, where we'll be able
6245 to do vCont action coalescing. */
6246 if (target_is_non_stop_p () && ::execution_direction
!= EXEC_REVERSE
)
6248 remote_thread_info
*remote_thr
;
6250 if (minus_one_ptid
== ptid
|| ptid
.is_pid ())
6251 remote_thr
= get_remote_thread_info (inferior_ptid
);
6253 remote_thr
= get_remote_thread_info (ptid
);
6255 remote_thr
->last_resume_step
= step
;
6256 remote_thr
->last_resume_sig
= siggnal
;
6260 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6261 (explained in remote-notif.c:handle_notification) so
6262 remote_notif_process is not called. We need find a place where
6263 it is safe to start a 'vNotif' sequence. It is good to do it
6264 before resuming inferior, because inferior was stopped and no RSP
6265 traffic at that moment. */
6266 if (!target_is_non_stop_p ())
6267 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
6269 rs
->last_resume_exec_dir
= ::execution_direction
;
6271 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
6272 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
6273 remote_resume_with_hc (ptid
, step
, siggnal
);
6275 /* We are about to start executing the inferior, let's register it
6276 with the event loop. NOTE: this is the one place where all the
6277 execution commands end up. We could alternatively do this in each
6278 of the execution commands in infcmd.c. */
6279 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6280 into infcmd.c in order to allow inferior function calls to work
6281 NOT asynchronously. */
6282 if (target_can_async_p ())
6285 /* We've just told the target to resume. The remote server will
6286 wait for the inferior to stop, and then send a stop reply. In
6287 the mean time, we can't start another command/query ourselves
6288 because the stub wouldn't be ready to process it. This applies
6289 only to the base all-stop protocol, however. In non-stop (which
6290 only supports vCont), the stub replies with an "OK", and is
6291 immediate able to process further serial input. */
6292 if (!target_is_non_stop_p ())
6293 rs
->waiting_for_stop_reply
= 1;
6296 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
6298 /* Private per-inferior info for target remote processes. */
6300 struct remote_inferior
: public private_inferior
6302 /* Whether we can send a wildcard vCont for this process. */
6303 bool may_wildcard_vcont
= true;
6306 /* Get the remote private inferior data associated to INF. */
6308 static remote_inferior
*
6309 get_remote_inferior (inferior
*inf
)
6311 if (inf
->priv
== NULL
)
6312 inf
->priv
.reset (new remote_inferior
);
6314 return static_cast<remote_inferior
*> (inf
->priv
.get ());
6317 /* Class used to track the construction of a vCont packet in the
6318 outgoing packet buffer. This is used to send multiple vCont
6319 packets if we have more actions than would fit a single packet. */
6324 explicit vcont_builder (remote_target
*remote
)
6331 void push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
);
6336 /* The remote target. */
6337 remote_target
*m_remote
;
6339 /* Pointer to the first action. P points here if no action has been
6341 char *m_first_action
;
6343 /* Where the next action will be appended. */
6346 /* The end of the buffer. Must never write past this. */
6350 /* Prepare the outgoing buffer for a new vCont packet. */
6353 vcont_builder::restart ()
6355 struct remote_state
*rs
= m_remote
->get_remote_state ();
6357 m_p
= rs
->buf
.data ();
6358 m_endp
= m_p
+ m_remote
->get_remote_packet_size ();
6359 m_p
+= xsnprintf (m_p
, m_endp
- m_p
, "vCont");
6360 m_first_action
= m_p
;
6363 /* If the vCont packet being built has any action, send it to the
6367 vcont_builder::flush ()
6369 struct remote_state
*rs
;
6371 if (m_p
== m_first_action
)
6374 rs
= m_remote
->get_remote_state ();
6375 m_remote
->putpkt (rs
->buf
);
6376 m_remote
->getpkt (&rs
->buf
, 0);
6377 if (strcmp (rs
->buf
.data (), "OK") != 0)
6378 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
.data ());
6381 /* The largest action is range-stepping, with its two addresses. This
6382 is more than sufficient. If a new, bigger action is created, it'll
6383 quickly trigger a failed assertion in append_resumption (and we'll
6385 #define MAX_ACTION_SIZE 200
6387 /* Append a new vCont action in the outgoing packet being built. If
6388 the action doesn't fit the packet along with previous actions, push
6389 what we've got so far to the remote end and start over a new vCont
6390 packet (with the new action). */
6393 vcont_builder::push_action (ptid_t ptid
, bool step
, gdb_signal siggnal
)
6395 char buf
[MAX_ACTION_SIZE
+ 1];
6397 char *endp
= m_remote
->append_resumption (buf
, buf
+ sizeof (buf
),
6398 ptid
, step
, siggnal
);
6400 /* Check whether this new action would fit in the vCont packet along
6401 with previous actions. If not, send what we've got so far and
6402 start a new vCont packet. */
6403 size_t rsize
= endp
- buf
;
6404 if (rsize
> m_endp
- m_p
)
6409 /* Should now fit. */
6410 gdb_assert (rsize
<= m_endp
- m_p
);
6413 memcpy (m_p
, buf
, rsize
);
6418 /* to_commit_resume implementation. */
6421 remote_target::commit_resume ()
6423 int any_process_wildcard
;
6424 int may_global_wildcard_vcont
;
6426 /* If connected in all-stop mode, we'd send the remote resume
6427 request directly from remote_resume. Likewise if
6428 reverse-debugging, as there are no defined vCont actions for
6429 reverse execution. */
6430 if (!target_is_non_stop_p () || ::execution_direction
== EXEC_REVERSE
)
6433 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6434 instead of resuming all threads of each process individually.
6435 However, if any thread of a process must remain halted, we can't
6436 send wildcard resumes and must send one action per thread.
6438 Care must be taken to not resume threads/processes the server
6439 side already told us are stopped, but the core doesn't know about
6440 yet, because the events are still in the vStopped notification
6443 #1 => vCont s:p1.1;c
6445 #3 <= %Stopped T05 p1.1
6450 #8 (infrun handles the stop for p1.1 and continues stepping)
6451 #9 => vCont s:p1.1;c
6453 The last vCont above would resume thread p1.2 by mistake, because
6454 the server has no idea that the event for p1.2 had not been
6457 The server side must similarly ignore resume actions for the
6458 thread that has a pending %Stopped notification (and any other
6459 threads with events pending), until GDB acks the notification
6460 with vStopped. Otherwise, e.g., the following case is
6463 #1 => g (or any other packet)
6465 #3 <= %Stopped T05 p1.2
6466 #4 => vCont s:p1.1;c
6469 Above, the server must not resume thread p1.2. GDB can't know
6470 that p1.2 stopped until it acks the %Stopped notification, and
6471 since from GDB's perspective all threads should be running, it
6474 Finally, special care must also be given to handling fork/vfork
6475 events. A (v)fork event actually tells us that two processes
6476 stopped -- the parent and the child. Until we follow the fork,
6477 we must not resume the child. Therefore, if we have a pending
6478 fork follow, we must not send a global wildcard resume action
6479 (vCont;c). We can still send process-wide wildcards though. */
6481 /* Start by assuming a global wildcard (vCont;c) is possible. */
6482 may_global_wildcard_vcont
= 1;
6484 /* And assume every process is individually wildcard-able too. */
6485 for (inferior
*inf
: all_non_exited_inferiors ())
6487 remote_inferior
*priv
= get_remote_inferior (inf
);
6489 priv
->may_wildcard_vcont
= true;
6492 /* Check for any pending events (not reported or processed yet) and
6493 disable process and global wildcard resumes appropriately. */
6494 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6496 for (thread_info
*tp
: all_non_exited_threads ())
6498 /* If a thread of a process is not meant to be resumed, then we
6499 can't wildcard that process. */
6502 get_remote_inferior (tp
->inf
)->may_wildcard_vcont
= false;
6504 /* And if we can't wildcard a process, we can't wildcard
6505 everything either. */
6506 may_global_wildcard_vcont
= 0;
6510 /* If a thread is the parent of an unfollowed fork, then we
6511 can't do a global wildcard, as that would resume the fork
6513 if (is_pending_fork_parent_thread (tp
))
6514 may_global_wildcard_vcont
= 0;
6517 /* Now let's build the vCont packet(s). Actions must be appended
6518 from narrower to wider scopes (thread -> process -> global). If
6519 we end up with too many actions for a single packet vcont_builder
6520 flushes the current vCont packet to the remote side and starts a
6522 struct vcont_builder
vcont_builder (this);
6524 /* Threads first. */
6525 for (thread_info
*tp
: all_non_exited_threads ())
6527 remote_thread_info
*remote_thr
= get_remote_thread_info (tp
);
6529 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6532 gdb_assert (!thread_is_in_step_over_chain (tp
));
6534 if (!remote_thr
->last_resume_step
6535 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6536 && get_remote_inferior (tp
->inf
)->may_wildcard_vcont
)
6538 /* We'll send a wildcard resume instead. */
6539 remote_thr
->vcont_resumed
= 1;
6543 vcont_builder
.push_action (tp
->ptid
,
6544 remote_thr
->last_resume_step
,
6545 remote_thr
->last_resume_sig
);
6546 remote_thr
->vcont_resumed
= 1;
6549 /* Now check whether we can send any process-wide wildcard. This is
6550 to avoid sending a global wildcard in the case nothing is
6551 supposed to be resumed. */
6552 any_process_wildcard
= 0;
6554 for (inferior
*inf
: all_non_exited_inferiors ())
6556 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6558 any_process_wildcard
= 1;
6563 if (any_process_wildcard
)
6565 /* If all processes are wildcard-able, then send a single "c"
6566 action, otherwise, send an "all (-1) threads of process"
6567 continue action for each running process, if any. */
6568 if (may_global_wildcard_vcont
)
6570 vcont_builder
.push_action (minus_one_ptid
,
6571 false, GDB_SIGNAL_0
);
6575 for (inferior
*inf
: all_non_exited_inferiors ())
6577 if (get_remote_inferior (inf
)->may_wildcard_vcont
)
6579 vcont_builder
.push_action (ptid_t (inf
->pid
),
6580 false, GDB_SIGNAL_0
);
6586 vcont_builder
.flush ();
6591 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6592 thread, all threads of a remote process, or all threads of all
6596 remote_target::remote_stop_ns (ptid_t ptid
)
6598 struct remote_state
*rs
= get_remote_state ();
6599 char *p
= rs
->buf
.data ();
6600 char *endp
= p
+ get_remote_packet_size ();
6602 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6603 remote_vcont_probe ();
6605 if (!rs
->supports_vCont
.t
)
6606 error (_("Remote server does not support stopping threads"));
6608 if (ptid
== minus_one_ptid
6609 || (!remote_multi_process_p (rs
) && ptid
.is_pid ()))
6610 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6615 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6618 /* All (-1) threads of process. */
6619 nptid
= ptid_t (ptid
.pid (), -1, 0);
6622 /* Small optimization: if we already have a stop reply for
6623 this thread, no use in telling the stub we want this
6625 if (peek_stop_reply (ptid
))
6631 write_ptid (p
, endp
, nptid
);
6634 /* In non-stop, we get an immediate OK reply. The stop reply will
6635 come in asynchronously by notification. */
6637 getpkt (&rs
->buf
, 0);
6638 if (strcmp (rs
->buf
.data (), "OK") != 0)
6639 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
).c_str (),
6643 /* All-stop version of target_interrupt. Sends a break or a ^C to
6644 interrupt the remote target. It is undefined which thread of which
6645 process reports the interrupt. */
6648 remote_target::remote_interrupt_as ()
6650 struct remote_state
*rs
= get_remote_state ();
6652 rs
->ctrlc_pending_p
= 1;
6654 /* If the inferior is stopped already, but the core didn't know
6655 about it yet, just ignore the request. The cached wait status
6656 will be collected in remote_wait. */
6657 if (rs
->cached_wait_status
)
6660 /* Send interrupt_sequence to remote target. */
6661 send_interrupt_sequence ();
6664 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6665 the remote target. It is undefined which thread of which process
6666 reports the interrupt. Throws an error if the packet is not
6667 supported by the server. */
6670 remote_target::remote_interrupt_ns ()
6672 struct remote_state
*rs
= get_remote_state ();
6673 char *p
= rs
->buf
.data ();
6674 char *endp
= p
+ get_remote_packet_size ();
6676 xsnprintf (p
, endp
- p
, "vCtrlC");
6678 /* In non-stop, we get an immediate OK reply. The stop reply will
6679 come in asynchronously by notification. */
6681 getpkt (&rs
->buf
, 0);
6683 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6687 case PACKET_UNKNOWN
:
6688 error (_("No support for interrupting the remote target."));
6690 error (_("Interrupting target failed: %s"), rs
->buf
.data ());
6694 /* Implement the to_stop function for the remote targets. */
6697 remote_target::stop (ptid_t ptid
)
6700 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6702 if (target_is_non_stop_p ())
6703 remote_stop_ns (ptid
);
6706 /* We don't currently have a way to transparently pause the
6707 remote target in all-stop mode. Interrupt it instead. */
6708 remote_interrupt_as ();
6712 /* Implement the to_interrupt function for the remote targets. */
6715 remote_target::interrupt ()
6718 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6720 if (target_is_non_stop_p ())
6721 remote_interrupt_ns ();
6723 remote_interrupt_as ();
6726 /* Implement the to_pass_ctrlc function for the remote targets. */
6729 remote_target::pass_ctrlc ()
6731 struct remote_state
*rs
= get_remote_state ();
6734 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6736 /* If we're starting up, we're not fully synced yet. Quit
6738 if (rs
->starting_up
)
6740 /* If ^C has already been sent once, offer to disconnect. */
6741 else if (rs
->ctrlc_pending_p
)
6744 target_interrupt ();
6747 /* Ask the user what to do when an interrupt is received. */
6750 remote_target::interrupt_query ()
6752 struct remote_state
*rs
= get_remote_state ();
6754 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6756 if (query (_("The target is not responding to interrupt requests.\n"
6757 "Stop debugging it? ")))
6759 remote_unpush_target ();
6760 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6765 if (query (_("Interrupted while waiting for the program.\n"
6766 "Give up waiting? ")))
6771 /* Enable/disable target terminal ownership. Most targets can use
6772 terminal groups to control terminal ownership. Remote targets are
6773 different in that explicit transfer of ownership to/from GDB/target
6777 remote_target::terminal_inferior ()
6779 /* NOTE: At this point we could also register our selves as the
6780 recipient of all input. Any characters typed could then be
6781 passed on down to the target. */
6785 remote_target::terminal_ours ()
6790 remote_console_output (const char *msg
)
6794 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6797 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6801 fputs_unfiltered (tb
, gdb_stdtarg
);
6803 gdb_flush (gdb_stdtarg
);
6806 struct stop_reply
: public notif_event
6810 /* The identifier of the thread about this event */
6813 /* The remote state this event is associated with. When the remote
6814 connection, represented by a remote_state object, is closed,
6815 all the associated stop_reply events should be released. */
6816 struct remote_state
*rs
;
6818 struct target_waitstatus ws
;
6820 /* The architecture associated with the expedited registers. */
6823 /* Expedited registers. This makes remote debugging a bit more
6824 efficient for those targets that provide critical registers as
6825 part of their normal status mechanism (as another roundtrip to
6826 fetch them is avoided). */
6827 std::vector
<cached_reg_t
> regcache
;
6829 enum target_stop_reason stop_reason
;
6831 CORE_ADDR watch_data_address
;
6836 /* Return the length of the stop reply queue. */
6839 remote_target::stop_reply_queue_length ()
6841 remote_state
*rs
= get_remote_state ();
6842 return rs
->stop_reply_queue
.size ();
6846 remote_notif_stop_parse (remote_target
*remote
,
6847 struct notif_client
*self
, const char *buf
,
6848 struct notif_event
*event
)
6850 remote
->remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6854 remote_notif_stop_ack (remote_target
*remote
,
6855 struct notif_client
*self
, const char *buf
,
6856 struct notif_event
*event
)
6858 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6861 putpkt (remote
, self
->ack_command
);
6863 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6865 /* We got an unknown stop reply. */
6866 error (_("Unknown stop reply"));
6869 remote
->push_stop_reply (stop_reply
);
6873 remote_notif_stop_can_get_pending_events (remote_target
*remote
,
6874 struct notif_client
*self
)
6876 /* We can't get pending events in remote_notif_process for
6877 notification stop, and we have to do this in remote_wait_ns
6878 instead. If we fetch all queued events from stub, remote stub
6879 may exit and we have no chance to process them back in
6881 remote_state
*rs
= remote
->get_remote_state ();
6882 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
6886 stop_reply::~stop_reply ()
6888 for (cached_reg_t
®
: regcache
)
6892 static notif_event_up
6893 remote_notif_stop_alloc_reply ()
6895 return notif_event_up (new struct stop_reply ());
6898 /* A client of notification Stop. */
6900 struct notif_client notif_client_stop
=
6904 remote_notif_stop_parse
,
6905 remote_notif_stop_ack
,
6906 remote_notif_stop_can_get_pending_events
,
6907 remote_notif_stop_alloc_reply
,
6911 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6912 the pid of the process that owns the threads we want to check, or
6913 -1 if we want to check all threads. */
6916 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6919 if (ws
->kind
== TARGET_WAITKIND_FORKED
6920 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6922 if (event_pid
== -1 || event_pid
== thread_ptid
.pid ())
6929 /* Return the thread's pending status used to determine whether the
6930 thread is a fork parent stopped at a fork event. */
6932 static struct target_waitstatus
*
6933 thread_pending_fork_status (struct thread_info
*thread
)
6935 if (thread
->suspend
.waitstatus_pending_p
)
6936 return &thread
->suspend
.waitstatus
;
6938 return &thread
->pending_follow
;
6941 /* Determine if THREAD is a pending fork parent thread. */
6944 is_pending_fork_parent_thread (struct thread_info
*thread
)
6946 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6949 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6952 /* If CONTEXT contains any fork child threads that have not been
6953 reported yet, remove them from the CONTEXT list. If such a
6954 thread exists it is because we are stopped at a fork catchpoint
6955 and have not yet called follow_fork, which will set up the
6956 host-side data structures for the new process. */
6959 remote_target::remove_new_fork_children (threads_listing_context
*context
)
6962 struct notif_client
*notif
= ¬if_client_stop
;
6964 /* For any threads stopped at a fork event, remove the corresponding
6965 fork child threads from the CONTEXT list. */
6966 for (thread_info
*thread
: all_non_exited_threads ())
6968 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6970 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6971 context
->remove_thread (ws
->value
.related_pid
);
6974 /* Check for any pending fork events (not reported or processed yet)
6975 in process PID and remove those fork child threads from the
6976 CONTEXT list as well. */
6977 remote_notif_get_pending_events (notif
);
6978 for (auto &event
: get_remote_state ()->stop_reply_queue
)
6979 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6980 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6981 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6982 context
->remove_thread (event
->ws
.value
.related_pid
);
6985 /* Check whether any event pending in the vStopped queue would prevent
6986 a global or process wildcard vCont action. Clear
6987 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6988 and clear the event inferior's may_wildcard_vcont flag if we can't
6989 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6992 remote_target::check_pending_events_prevent_wildcard_vcont
6993 (int *may_global_wildcard
)
6995 struct notif_client
*notif
= ¬if_client_stop
;
6997 remote_notif_get_pending_events (notif
);
6998 for (auto &event
: get_remote_state ()->stop_reply_queue
)
7000 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
7001 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
7004 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
7005 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
7006 *may_global_wildcard
= 0;
7008 struct inferior
*inf
= find_inferior_ptid (event
->ptid
);
7010 /* This may be the first time we heard about this process.
7011 Regardless, we must not do a global wildcard resume, otherwise
7012 we'd resume this process too. */
7013 *may_global_wildcard
= 0;
7015 get_remote_inferior (inf
)->may_wildcard_vcont
= false;
7019 /* Discard all pending stop replies of inferior INF. */
7022 remote_target::discard_pending_stop_replies (struct inferior
*inf
)
7024 struct stop_reply
*reply
;
7025 struct remote_state
*rs
= get_remote_state ();
7026 struct remote_notif_state
*rns
= rs
->notif_state
;
7028 /* This function can be notified when an inferior exists. When the
7029 target is not remote, the notification state is NULL. */
7030 if (rs
->remote_desc
== NULL
)
7033 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
7035 /* Discard the in-flight notification. */
7036 if (reply
!= NULL
&& reply
->ptid
.pid () == inf
->pid
)
7039 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
7042 /* Discard the stop replies we have already pulled with
7044 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7045 rs
->stop_reply_queue
.end (),
7046 [=] (const stop_reply_up
&event
)
7048 return event
->ptid
.pid () == inf
->pid
;
7050 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7053 /* Discard the stop replies for RS in stop_reply_queue. */
7056 remote_target::discard_pending_stop_replies_in_queue ()
7058 remote_state
*rs
= get_remote_state ();
7060 /* Discard the stop replies we have already pulled with
7062 auto iter
= std::remove_if (rs
->stop_reply_queue
.begin (),
7063 rs
->stop_reply_queue
.end (),
7064 [=] (const stop_reply_up
&event
)
7066 return event
->rs
== rs
;
7068 rs
->stop_reply_queue
.erase (iter
, rs
->stop_reply_queue
.end ());
7071 /* Remove the first reply in 'stop_reply_queue' which matches
7075 remote_target::remote_notif_remove_queued_reply (ptid_t ptid
)
7077 remote_state
*rs
= get_remote_state ();
7079 auto iter
= std::find_if (rs
->stop_reply_queue
.begin (),
7080 rs
->stop_reply_queue
.end (),
7081 [=] (const stop_reply_up
&event
)
7083 return event
->ptid
.matches (ptid
);
7085 struct stop_reply
*result
;
7086 if (iter
== rs
->stop_reply_queue
.end ())
7090 result
= iter
->release ();
7091 rs
->stop_reply_queue
.erase (iter
);
7095 fprintf_unfiltered (gdb_stdlog
,
7096 "notif: discard queued event: 'Stop' in %s\n",
7097 target_pid_to_str (ptid
).c_str ());
7102 /* Look for a queued stop reply belonging to PTID. If one is found,
7103 remove it from the queue, and return it. Returns NULL if none is
7104 found. If there are still queued events left to process, tell the
7105 event loop to get back to target_wait soon. */
7108 remote_target::queued_stop_reply (ptid_t ptid
)
7110 remote_state
*rs
= get_remote_state ();
7111 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
7113 if (!rs
->stop_reply_queue
.empty ())
7115 /* There's still at least an event left. */
7116 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7122 /* Push a fully parsed stop reply in the stop reply queue. Since we
7123 know that we now have at least one queued event left to pass to the
7124 core side, tell the event loop to get back to target_wait soon. */
7127 remote_target::push_stop_reply (struct stop_reply
*new_event
)
7129 remote_state
*rs
= get_remote_state ();
7130 rs
->stop_reply_queue
.push_back (stop_reply_up (new_event
));
7133 fprintf_unfiltered (gdb_stdlog
,
7134 "notif: push 'Stop' %s to queue %d\n",
7135 target_pid_to_str (new_event
->ptid
).c_str (),
7136 int (rs
->stop_reply_queue
.size ()));
7138 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7141 /* Returns true if we have a stop reply for PTID. */
7144 remote_target::peek_stop_reply (ptid_t ptid
)
7146 remote_state
*rs
= get_remote_state ();
7147 for (auto &event
: rs
->stop_reply_queue
)
7148 if (ptid
== event
->ptid
7149 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
)
7154 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
7155 starting with P and ending with PEND matches PREFIX. */
7158 strprefix (const char *p
, const char *pend
, const char *prefix
)
7160 for ( ; p
< pend
; p
++, prefix
++)
7163 return *prefix
== '\0';
7166 /* Parse the stop reply in BUF. Either the function succeeds, and the
7167 result is stored in EVENT, or throws an error. */
7170 remote_target::remote_parse_stop_reply (const char *buf
, stop_reply
*event
)
7172 remote_arch_state
*rsa
= NULL
;
7177 event
->ptid
= null_ptid
;
7178 event
->rs
= get_remote_state ();
7179 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
7180 event
->ws
.value
.integer
= 0;
7181 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
7182 event
->regcache
.clear ();
7187 case 'T': /* Status with PC, SP, FP, ... */
7188 /* Expedited reply, containing Signal, {regno, reg} repeat. */
7189 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
7191 n... = register number
7192 r... = register contents
7195 p
= &buf
[3]; /* after Txx */
7201 p1
= strchr (p
, ':');
7203 error (_("Malformed packet(a) (missing colon): %s\n\
7207 error (_("Malformed packet(a) (missing register number): %s\n\
7211 /* Some "registers" are actually extended stop information.
7212 Note if you're adding a new entry here: GDB 7.9 and
7213 earlier assume that all register "numbers" that start
7214 with an hex digit are real register numbers. Make sure
7215 the server only sends such a packet if it knows the
7216 client understands it. */
7218 if (strprefix (p
, p1
, "thread"))
7219 event
->ptid
= read_ptid (++p1
, &p
);
7220 else if (strprefix (p
, p1
, "syscall_entry"))
7224 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
7225 p
= unpack_varlen_hex (++p1
, &sysno
);
7226 event
->ws
.value
.syscall_number
= (int) sysno
;
7228 else if (strprefix (p
, p1
, "syscall_return"))
7232 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
7233 p
= unpack_varlen_hex (++p1
, &sysno
);
7234 event
->ws
.value
.syscall_number
= (int) sysno
;
7236 else if (strprefix (p
, p1
, "watch")
7237 || strprefix (p
, p1
, "rwatch")
7238 || strprefix (p
, p1
, "awatch"))
7240 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
7241 p
= unpack_varlen_hex (++p1
, &addr
);
7242 event
->watch_data_address
= (CORE_ADDR
) addr
;
7244 else if (strprefix (p
, p1
, "swbreak"))
7246 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
7248 /* Make sure the stub doesn't forget to indicate support
7250 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
7251 error (_("Unexpected swbreak stop reason"));
7253 /* The value part is documented as "must be empty",
7254 though we ignore it, in case we ever decide to make
7255 use of it in a backward compatible way. */
7256 p
= strchrnul (p1
+ 1, ';');
7258 else if (strprefix (p
, p1
, "hwbreak"))
7260 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
7262 /* Make sure the stub doesn't forget to indicate support
7264 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
7265 error (_("Unexpected hwbreak stop reason"));
7268 p
= strchrnul (p1
+ 1, ';');
7270 else if (strprefix (p
, p1
, "library"))
7272 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
7273 p
= strchrnul (p1
+ 1, ';');
7275 else if (strprefix (p
, p1
, "replaylog"))
7277 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
7278 /* p1 will indicate "begin" or "end", but it makes
7279 no difference for now, so ignore it. */
7280 p
= strchrnul (p1
+ 1, ';');
7282 else if (strprefix (p
, p1
, "core"))
7286 p
= unpack_varlen_hex (++p1
, &c
);
7289 else if (strprefix (p
, p1
, "fork"))
7291 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7292 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
7294 else if (strprefix (p
, p1
, "vfork"))
7296 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
7297 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
7299 else if (strprefix (p
, p1
, "vforkdone"))
7301 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
7302 p
= strchrnul (p1
+ 1, ';');
7304 else if (strprefix (p
, p1
, "exec"))
7309 /* Determine the length of the execd pathname. */
7310 p
= unpack_varlen_hex (++p1
, &ignored
);
7311 pathlen
= (p
- p1
) / 2;
7313 /* Save the pathname for event reporting and for
7314 the next run command. */
7315 gdb::unique_xmalloc_ptr
<char[]> pathname
7316 ((char *) xmalloc (pathlen
+ 1));
7317 hex2bin (p1
, (gdb_byte
*) pathname
.get (), pathlen
);
7318 pathname
[pathlen
] = '\0';
7320 /* This is freed during event handling. */
7321 event
->ws
.value
.execd_pathname
= pathname
.release ();
7322 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
7324 /* Skip the registers included in this packet, since
7325 they may be for an architecture different from the
7326 one used by the original program. */
7329 else if (strprefix (p
, p1
, "create"))
7331 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
7332 p
= strchrnul (p1
+ 1, ';');
7341 p
= strchrnul (p1
+ 1, ';');
7346 /* Maybe a real ``P'' register number. */
7347 p_temp
= unpack_varlen_hex (p
, &pnum
);
7348 /* If the first invalid character is the colon, we got a
7349 register number. Otherwise, it's an unknown stop
7353 /* If we haven't parsed the event's thread yet, find
7354 it now, in order to find the architecture of the
7355 reported expedited registers. */
7356 if (event
->ptid
== null_ptid
)
7358 const char *thr
= strstr (p1
+ 1, ";thread:");
7360 event
->ptid
= read_ptid (thr
+ strlen (";thread:"),
7364 /* Either the current thread hasn't changed,
7365 or the inferior is not multi-threaded.
7366 The event must be for the thread we last
7367 set as (or learned as being) current. */
7368 event
->ptid
= event
->rs
->general_thread
;
7374 inferior
*inf
= (event
->ptid
== null_ptid
7376 : find_inferior_ptid (event
->ptid
));
7377 /* If this is the first time we learn anything
7378 about this process, skip the registers
7379 included in this packet, since we don't yet
7380 know which architecture to use to parse them.
7381 We'll determine the architecture later when
7382 we process the stop reply and retrieve the
7383 target description, via
7384 remote_notice_new_inferior ->
7385 post_create_inferior. */
7388 p
= strchrnul (p1
+ 1, ';');
7393 event
->arch
= inf
->gdbarch
;
7394 rsa
= event
->rs
->get_remote_arch_state (event
->arch
);
7398 = packet_reg_from_pnum (event
->arch
, rsa
, pnum
);
7399 cached_reg_t cached_reg
;
7402 error (_("Remote sent bad register number %s: %s\n\
7404 hex_string (pnum
), p
, buf
);
7406 cached_reg
.num
= reg
->regnum
;
7407 cached_reg
.data
= (gdb_byte
*)
7408 xmalloc (register_size (event
->arch
, reg
->regnum
));
7411 fieldsize
= hex2bin (p
, cached_reg
.data
,
7412 register_size (event
->arch
, reg
->regnum
));
7414 if (fieldsize
< register_size (event
->arch
, reg
->regnum
))
7415 warning (_("Remote reply is too short: %s"), buf
);
7417 event
->regcache
.push_back (cached_reg
);
7421 /* Not a number. Silently skip unknown optional
7423 p
= strchrnul (p1
+ 1, ';');
7428 error (_("Remote register badly formatted: %s\nhere: %s"),
7433 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7437 case 'S': /* Old style status, just signal only. */
7441 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7442 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7443 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7444 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7446 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7449 case 'w': /* Thread exited. */
7453 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7454 p
= unpack_varlen_hex (&buf
[1], &value
);
7455 event
->ws
.value
.integer
= value
;
7457 error (_("stop reply packet badly formatted: %s"), buf
);
7458 event
->ptid
= read_ptid (++p
, NULL
);
7461 case 'W': /* Target exited. */
7467 /* GDB used to accept only 2 hex chars here. Stubs should
7468 only send more if they detect GDB supports multi-process
7470 p
= unpack_varlen_hex (&buf
[1], &value
);
7474 /* The remote process exited. */
7475 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7476 event
->ws
.value
.integer
= value
;
7480 /* The remote process exited with a signal. */
7481 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7482 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7483 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7485 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7488 /* If no process is specified, assume inferior_ptid. */
7489 pid
= inferior_ptid
.pid ();
7498 else if (startswith (p
, "process:"))
7502 p
+= sizeof ("process:") - 1;
7503 unpack_varlen_hex (p
, &upid
);
7507 error (_("unknown stop reply packet: %s"), buf
);
7510 error (_("unknown stop reply packet: %s"), buf
);
7511 event
->ptid
= ptid_t (pid
);
7515 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7516 event
->ptid
= minus_one_ptid
;
7520 if (target_is_non_stop_p () && event
->ptid
== null_ptid
)
7521 error (_("No process or thread specified in stop reply: %s"), buf
);
7524 /* When the stub wants to tell GDB about a new notification reply, it
7525 sends a notification (%Stop, for example). Those can come it at
7526 any time, hence, we have to make sure that any pending
7527 putpkt/getpkt sequence we're making is finished, before querying
7528 the stub for more events with the corresponding ack command
7529 (vStopped, for example). E.g., if we started a vStopped sequence
7530 immediately upon receiving the notification, something like this
7538 1.6) <-- (registers reply to step #1.3)
7540 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7543 To solve this, whenever we parse a %Stop notification successfully,
7544 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7545 doing whatever we were doing:
7551 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7552 2.5) <-- (registers reply to step #2.3)
7554 Eventualy after step #2.5, we return to the event loop, which
7555 notices there's an event on the
7556 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7557 associated callback --- the function below. At this point, we're
7558 always safe to start a vStopped sequence. :
7561 2.7) <-- T05 thread:2
7567 remote_target::remote_notif_get_pending_events (notif_client
*nc
)
7569 struct remote_state
*rs
= get_remote_state ();
7571 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7574 fprintf_unfiltered (gdb_stdlog
,
7575 "notif: process: '%s' ack pending event\n",
7579 nc
->ack (this, nc
, rs
->buf
.data (),
7580 rs
->notif_state
->pending_event
[nc
->id
]);
7581 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7585 getpkt (&rs
->buf
, 0);
7586 if (strcmp (rs
->buf
.data (), "OK") == 0)
7589 remote_notif_ack (this, nc
, rs
->buf
.data ());
7595 fprintf_unfiltered (gdb_stdlog
,
7596 "notif: process: '%s' no pending reply\n",
7601 /* Wrapper around remote_target::remote_notif_get_pending_events to
7602 avoid having to export the whole remote_target class. */
7605 remote_notif_get_pending_events (remote_target
*remote
, notif_client
*nc
)
7607 remote
->remote_notif_get_pending_events (nc
);
7610 /* Called when it is decided that STOP_REPLY holds the info of the
7611 event that is to be returned to the core. This function always
7612 destroys STOP_REPLY. */
7615 remote_target::process_stop_reply (struct stop_reply
*stop_reply
,
7616 struct target_waitstatus
*status
)
7620 *status
= stop_reply
->ws
;
7621 ptid
= stop_reply
->ptid
;
7623 /* If no thread/process was reported by the stub, assume the current
7625 if (ptid
== null_ptid
)
7626 ptid
= inferior_ptid
;
7628 if (status
->kind
!= TARGET_WAITKIND_EXITED
7629 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7630 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7632 /* Expedited registers. */
7633 if (!stop_reply
->regcache
.empty ())
7635 struct regcache
*regcache
7636 = get_thread_arch_regcache (ptid
, stop_reply
->arch
);
7638 for (cached_reg_t
®
: stop_reply
->regcache
)
7640 regcache
->raw_supply (reg
.num
, reg
.data
);
7644 stop_reply
->regcache
.clear ();
7647 remote_notice_new_inferior (ptid
, 0);
7648 remote_thread_info
*remote_thr
= get_remote_thread_info (ptid
);
7649 remote_thr
->core
= stop_reply
->core
;
7650 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7651 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7652 remote_thr
->vcont_resumed
= 0;
7659 /* The non-stop mode version of target_wait. */
7662 remote_target::wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7664 struct remote_state
*rs
= get_remote_state ();
7665 struct stop_reply
*stop_reply
;
7669 /* If in non-stop mode, get out of getpkt even if a
7670 notification is received. */
7672 ret
= getpkt_or_notif_sane (&rs
->buf
, 0 /* forever */, &is_notif
);
7675 if (ret
!= -1 && !is_notif
)
7678 case 'E': /* Error of some sort. */
7679 /* We're out of sync with the target now. Did it continue
7680 or not? We can't tell which thread it was in non-stop,
7681 so just ignore this. */
7682 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
7684 case 'O': /* Console output. */
7685 remote_console_output (&rs
->buf
[1]);
7688 warning (_("Invalid remote reply: %s"), rs
->buf
.data ());
7692 /* Acknowledge a pending stop reply that may have arrived in the
7694 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7695 remote_notif_get_pending_events (¬if_client_stop
);
7697 /* If indeed we noticed a stop reply, we're done. */
7698 stop_reply
= queued_stop_reply (ptid
);
7699 if (stop_reply
!= NULL
)
7700 return process_stop_reply (stop_reply
, status
);
7702 /* Still no event. If we're just polling for an event, then
7703 return to the event loop. */
7704 if (options
& TARGET_WNOHANG
)
7706 status
->kind
= TARGET_WAITKIND_IGNORE
;
7707 return minus_one_ptid
;
7710 /* Otherwise do a blocking wait. */
7711 ret
= getpkt_or_notif_sane (&rs
->buf
, 1 /* forever */, &is_notif
);
7715 /* Wait until the remote machine stops, then return, storing status in
7716 STATUS just as `wait' would. */
7719 remote_target::wait_as (ptid_t ptid
, target_waitstatus
*status
, int options
)
7721 struct remote_state
*rs
= get_remote_state ();
7722 ptid_t event_ptid
= null_ptid
;
7724 struct stop_reply
*stop_reply
;
7728 status
->kind
= TARGET_WAITKIND_IGNORE
;
7729 status
->value
.integer
= 0;
7731 stop_reply
= queued_stop_reply (ptid
);
7732 if (stop_reply
!= NULL
)
7733 return process_stop_reply (stop_reply
, status
);
7735 if (rs
->cached_wait_status
)
7736 /* Use the cached wait status, but only once. */
7737 rs
->cached_wait_status
= 0;
7742 int forever
= ((options
& TARGET_WNOHANG
) == 0
7743 && rs
->wait_forever_enabled_p
);
7745 if (!rs
->waiting_for_stop_reply
)
7747 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7748 return minus_one_ptid
;
7751 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7752 _never_ wait for ever -> test on target_is_async_p().
7753 However, before we do that we need to ensure that the caller
7754 knows how to take the target into/out of async mode. */
7755 ret
= getpkt_or_notif_sane (&rs
->buf
, forever
, &is_notif
);
7757 /* GDB gets a notification. Return to core as this event is
7759 if (ret
!= -1 && is_notif
)
7760 return minus_one_ptid
;
7762 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7763 return minus_one_ptid
;
7766 buf
= rs
->buf
.data ();
7768 /* Assume that the target has acknowledged Ctrl-C unless we receive
7769 an 'F' or 'O' packet. */
7770 if (buf
[0] != 'F' && buf
[0] != 'O')
7771 rs
->ctrlc_pending_p
= 0;
7775 case 'E': /* Error of some sort. */
7776 /* We're out of sync with the target now. Did it continue or
7777 not? Not is more likely, so report a stop. */
7778 rs
->waiting_for_stop_reply
= 0;
7780 warning (_("Remote failure reply: %s"), buf
);
7781 status
->kind
= TARGET_WAITKIND_STOPPED
;
7782 status
->value
.sig
= GDB_SIGNAL_0
;
7784 case 'F': /* File-I/O request. */
7785 /* GDB may access the inferior memory while handling the File-I/O
7786 request, but we don't want GDB accessing memory while waiting
7787 for a stop reply. See the comments in putpkt_binary. Set
7788 waiting_for_stop_reply to 0 temporarily. */
7789 rs
->waiting_for_stop_reply
= 0;
7790 remote_fileio_request (this, buf
, rs
->ctrlc_pending_p
);
7791 rs
->ctrlc_pending_p
= 0;
7792 /* GDB handled the File-I/O request, and the target is running
7793 again. Keep waiting for events. */
7794 rs
->waiting_for_stop_reply
= 1;
7796 case 'N': case 'T': case 'S': case 'X': case 'W':
7798 /* There is a stop reply to handle. */
7799 rs
->waiting_for_stop_reply
= 0;
7802 = (struct stop_reply
*) remote_notif_parse (this,
7806 event_ptid
= process_stop_reply (stop_reply
, status
);
7809 case 'O': /* Console output. */
7810 remote_console_output (buf
+ 1);
7813 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7815 /* Zero length reply means that we tried 'S' or 'C' and the
7816 remote system doesn't support it. */
7817 target_terminal::ours_for_output ();
7819 ("Can't send signals to this remote system. %s not sent.\n",
7820 gdb_signal_to_name (rs
->last_sent_signal
));
7821 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7822 target_terminal::inferior ();
7824 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7830 warning (_("Invalid remote reply: %s"), buf
);
7834 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7835 return minus_one_ptid
;
7836 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7838 /* Nothing interesting happened. If we're doing a non-blocking
7839 poll, we're done. Otherwise, go back to waiting. */
7840 if (options
& TARGET_WNOHANG
)
7841 return minus_one_ptid
;
7845 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7846 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7848 if (event_ptid
!= null_ptid
)
7849 record_currthread (rs
, event_ptid
);
7851 event_ptid
= inferior_ptid
;
7854 /* A process exit. Invalidate our notion of current thread. */
7855 record_currthread (rs
, minus_one_ptid
);
7860 /* Wait until the remote machine stops, then return, storing status in
7861 STATUS just as `wait' would. */
7864 remote_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7868 if (target_is_non_stop_p ())
7869 event_ptid
= wait_ns (ptid
, status
, options
);
7871 event_ptid
= wait_as (ptid
, status
, options
);
7873 if (target_is_async_p ())
7875 remote_state
*rs
= get_remote_state ();
7877 /* If there are are events left in the queue tell the event loop
7879 if (!rs
->stop_reply_queue
.empty ())
7880 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
7886 /* Fetch a single register using a 'p' packet. */
7889 remote_target::fetch_register_using_p (struct regcache
*regcache
,
7892 struct gdbarch
*gdbarch
= regcache
->arch ();
7893 struct remote_state
*rs
= get_remote_state ();
7895 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7898 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7901 if (reg
->pnum
== -1)
7904 p
= rs
->buf
.data ();
7906 p
+= hexnumstr (p
, reg
->pnum
);
7909 getpkt (&rs
->buf
, 0);
7911 buf
= rs
->buf
.data ();
7913 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_p
]))
7917 case PACKET_UNKNOWN
:
7920 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7921 gdbarch_register_name (regcache
->arch (),
7926 /* If this register is unfetchable, tell the regcache. */
7929 regcache
->raw_supply (reg
->regnum
, NULL
);
7933 /* Otherwise, parse and supply the value. */
7939 error (_("fetch_register_using_p: early buf termination"));
7941 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7944 regcache
->raw_supply (reg
->regnum
, regp
);
7948 /* Fetch the registers included in the target's 'g' packet. */
7951 remote_target::send_g_packet ()
7953 struct remote_state
*rs
= get_remote_state ();
7956 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "g");
7958 getpkt (&rs
->buf
, 0);
7959 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7960 error (_("Could not read registers; remote failure reply '%s'"),
7963 /* We can get out of synch in various cases. If the first character
7964 in the buffer is not a hex character, assume that has happened
7965 and try to fetch another packet to read. */
7966 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7967 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7968 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7969 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7972 fprintf_unfiltered (gdb_stdlog
,
7973 "Bad register packet; fetching a new packet\n");
7974 getpkt (&rs
->buf
, 0);
7977 buf_len
= strlen (rs
->buf
.data ());
7979 /* Sanity check the received packet. */
7980 if (buf_len
% 2 != 0)
7981 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
.data ());
7987 remote_target::process_g_packet (struct regcache
*regcache
)
7989 struct gdbarch
*gdbarch
= regcache
->arch ();
7990 struct remote_state
*rs
= get_remote_state ();
7991 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
7996 buf_len
= strlen (rs
->buf
.data ());
7998 /* Further sanity checks, with knowledge of the architecture. */
7999 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
8000 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8002 rsa
->sizeof_g_packet
, buf_len
/ 2,
8005 /* Save the size of the packet sent to us by the target. It is used
8006 as a heuristic when determining the max size of packets that the
8007 target can safely receive. */
8008 if (rsa
->actual_register_packet_size
== 0)
8009 rsa
->actual_register_packet_size
= buf_len
;
8011 /* If this is smaller than we guessed the 'g' packet would be,
8012 update our records. A 'g' reply that doesn't include a register's
8013 value implies either that the register is not available, or that
8014 the 'p' packet must be used. */
8015 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
8017 long sizeof_g_packet
= buf_len
/ 2;
8019 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8021 long offset
= rsa
->regs
[i
].offset
;
8022 long reg_size
= register_size (gdbarch
, i
);
8024 if (rsa
->regs
[i
].pnum
== -1)
8027 if (offset
>= sizeof_g_packet
)
8028 rsa
->regs
[i
].in_g_packet
= 0;
8029 else if (offset
+ reg_size
> sizeof_g_packet
)
8030 error (_("Truncated register %d in remote 'g' packet"), i
);
8032 rsa
->regs
[i
].in_g_packet
= 1;
8035 /* Looks valid enough, we can assume this is the correct length
8036 for a 'g' packet. It's important not to adjust
8037 rsa->sizeof_g_packet if we have truncated registers otherwise
8038 this "if" won't be run the next time the method is called
8039 with a packet of the same size and one of the internal errors
8040 below will trigger instead. */
8041 rsa
->sizeof_g_packet
= sizeof_g_packet
;
8044 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
8046 /* Unimplemented registers read as all bits zero. */
8047 memset (regs
, 0, rsa
->sizeof_g_packet
);
8049 /* Reply describes registers byte by byte, each byte encoded as two
8050 hex characters. Suck them all up, then supply them to the
8051 register cacheing/storage mechanism. */
8053 p
= rs
->buf
.data ();
8054 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
8056 if (p
[0] == 0 || p
[1] == 0)
8057 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
8058 internal_error (__FILE__
, __LINE__
,
8059 _("unexpected end of 'g' packet reply"));
8061 if (p
[0] == 'x' && p
[1] == 'x')
8062 regs
[i
] = 0; /* 'x' */
8064 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
8068 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8070 struct packet_reg
*r
= &rsa
->regs
[i
];
8071 long reg_size
= register_size (gdbarch
, i
);
8075 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
.data ()))
8076 /* This shouldn't happen - we adjusted in_g_packet above. */
8077 internal_error (__FILE__
, __LINE__
,
8078 _("unexpected end of 'g' packet reply"));
8079 else if (rs
->buf
[r
->offset
* 2] == 'x')
8081 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
.data ()));
8082 /* The register isn't available, mark it as such (at
8083 the same time setting the value to zero). */
8084 regcache
->raw_supply (r
->regnum
, NULL
);
8087 regcache
->raw_supply (r
->regnum
, regs
+ r
->offset
);
8093 remote_target::fetch_registers_using_g (struct regcache
*regcache
)
8096 process_g_packet (regcache
);
8099 /* Make the remote selected traceframe match GDB's selected
8103 remote_target::set_remote_traceframe ()
8106 struct remote_state
*rs
= get_remote_state ();
8108 if (rs
->remote_traceframe_number
== get_traceframe_number ())
8111 /* Avoid recursion, remote_trace_find calls us again. */
8112 rs
->remote_traceframe_number
= get_traceframe_number ();
8114 newnum
= target_trace_find (tfind_number
,
8115 get_traceframe_number (), 0, 0, NULL
);
8117 /* Should not happen. If it does, all bets are off. */
8118 if (newnum
!= get_traceframe_number ())
8119 warning (_("could not set remote traceframe"));
8123 remote_target::fetch_registers (struct regcache
*regcache
, int regnum
)
8125 struct gdbarch
*gdbarch
= regcache
->arch ();
8126 struct remote_state
*rs
= get_remote_state ();
8127 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8130 set_remote_traceframe ();
8131 set_general_thread (regcache
->ptid ());
8135 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8137 gdb_assert (reg
!= NULL
);
8139 /* If this register might be in the 'g' packet, try that first -
8140 we are likely to read more than one register. If this is the
8141 first 'g' packet, we might be overly optimistic about its
8142 contents, so fall back to 'p'. */
8143 if (reg
->in_g_packet
)
8145 fetch_registers_using_g (regcache
);
8146 if (reg
->in_g_packet
)
8150 if (fetch_register_using_p (regcache
, reg
))
8153 /* This register is not available. */
8154 regcache
->raw_supply (reg
->regnum
, NULL
);
8159 fetch_registers_using_g (regcache
);
8161 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8162 if (!rsa
->regs
[i
].in_g_packet
)
8163 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
8165 /* This register is not available. */
8166 regcache
->raw_supply (i
, NULL
);
8170 /* Prepare to store registers. Since we may send them all (using a
8171 'G' request), we have to read out the ones we don't want to change
8175 remote_target::prepare_to_store (struct regcache
*regcache
)
8177 struct remote_state
*rs
= get_remote_state ();
8178 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8181 /* Make sure the entire registers array is valid. */
8182 switch (packet_support (PACKET_P
))
8184 case PACKET_DISABLE
:
8185 case PACKET_SUPPORT_UNKNOWN
:
8186 /* Make sure all the necessary registers are cached. */
8187 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8188 if (rsa
->regs
[i
].in_g_packet
)
8189 regcache
->raw_update (rsa
->regs
[i
].regnum
);
8196 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
8197 packet was not recognized. */
8200 remote_target::store_register_using_P (const struct regcache
*regcache
,
8203 struct gdbarch
*gdbarch
= regcache
->arch ();
8204 struct remote_state
*rs
= get_remote_state ();
8205 /* Try storing a single register. */
8206 char *buf
= rs
->buf
.data ();
8207 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
8210 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
8213 if (reg
->pnum
== -1)
8216 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
8217 p
= buf
+ strlen (buf
);
8218 regcache
->raw_collect (reg
->regnum
, regp
);
8219 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
8221 getpkt (&rs
->buf
, 0);
8223 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
8228 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8229 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
.data ());
8230 case PACKET_UNKNOWN
:
8233 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
8237 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8238 contents of the register cache buffer. FIXME: ignores errors. */
8241 remote_target::store_registers_using_G (const struct regcache
*regcache
)
8243 struct remote_state
*rs
= get_remote_state ();
8244 remote_arch_state
*rsa
= rs
->get_remote_arch_state (regcache
->arch ());
8248 /* Extract all the registers in the regcache copying them into a
8253 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
8254 memset (regs
, 0, rsa
->sizeof_g_packet
);
8255 for (i
= 0; i
< gdbarch_num_regs (regcache
->arch ()); i
++)
8257 struct packet_reg
*r
= &rsa
->regs
[i
];
8260 regcache
->raw_collect (r
->regnum
, regs
+ r
->offset
);
8264 /* Command describes registers byte by byte,
8265 each byte encoded as two hex characters. */
8266 p
= rs
->buf
.data ();
8268 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
8270 getpkt (&rs
->buf
, 0);
8271 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
8272 error (_("Could not write registers; remote failure reply '%s'"),
8276 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8277 of the register cache buffer. FIXME: ignores errors. */
8280 remote_target::store_registers (struct regcache
*regcache
, int regnum
)
8282 struct gdbarch
*gdbarch
= regcache
->arch ();
8283 struct remote_state
*rs
= get_remote_state ();
8284 remote_arch_state
*rsa
= rs
->get_remote_arch_state (gdbarch
);
8287 set_remote_traceframe ();
8288 set_general_thread (regcache
->ptid ());
8292 packet_reg
*reg
= packet_reg_from_regnum (gdbarch
, rsa
, regnum
);
8294 gdb_assert (reg
!= NULL
);
8296 /* Always prefer to store registers using the 'P' packet if
8297 possible; we often change only a small number of registers.
8298 Sometimes we change a larger number; we'd need help from a
8299 higher layer to know to use 'G'. */
8300 if (store_register_using_P (regcache
, reg
))
8303 /* For now, don't complain if we have no way to write the
8304 register. GDB loses track of unavailable registers too
8305 easily. Some day, this may be an error. We don't have
8306 any way to read the register, either... */
8307 if (!reg
->in_g_packet
)
8310 store_registers_using_G (regcache
);
8314 store_registers_using_G (regcache
);
8316 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
8317 if (!rsa
->regs
[i
].in_g_packet
)
8318 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
8319 /* See above for why we do not issue an error here. */
8324 /* Return the number of hex digits in num. */
8327 hexnumlen (ULONGEST num
)
8331 for (i
= 0; num
!= 0; i
++)
8334 return std::max (i
, 1);
8337 /* Set BUF to the minimum number of hex digits representing NUM. */
8340 hexnumstr (char *buf
, ULONGEST num
)
8342 int len
= hexnumlen (num
);
8344 return hexnumnstr (buf
, num
, len
);
8348 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
8351 hexnumnstr (char *buf
, ULONGEST num
, int width
)
8357 for (i
= width
- 1; i
>= 0; i
--)
8359 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
8366 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
8369 remote_address_masked (CORE_ADDR addr
)
8371 unsigned int address_size
= remote_address_size
;
8373 /* If "remoteaddresssize" was not set, default to target address size. */
8375 address_size
= gdbarch_addr_bit (target_gdbarch ());
8377 if (address_size
> 0
8378 && address_size
< (sizeof (ULONGEST
) * 8))
8380 /* Only create a mask when that mask can safely be constructed
8381 in a ULONGEST variable. */
8384 mask
= (mask
<< address_size
) - 1;
8390 /* Determine whether the remote target supports binary downloading.
8391 This is accomplished by sending a no-op memory write of zero length
8392 to the target at the specified address. It does not suffice to send
8393 the whole packet, since many stubs strip the eighth bit and
8394 subsequently compute a wrong checksum, which causes real havoc with
8397 NOTE: This can still lose if the serial line is not eight-bit
8398 clean. In cases like this, the user should clear "remote
8402 remote_target::check_binary_download (CORE_ADDR addr
)
8404 struct remote_state
*rs
= get_remote_state ();
8406 switch (packet_support (PACKET_X
))
8408 case PACKET_DISABLE
:
8412 case PACKET_SUPPORT_UNKNOWN
:
8416 p
= rs
->buf
.data ();
8418 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8420 p
+= hexnumstr (p
, (ULONGEST
) 0);
8424 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8425 getpkt (&rs
->buf
, 0);
8427 if (rs
->buf
[0] == '\0')
8430 fprintf_unfiltered (gdb_stdlog
,
8431 "binary downloading NOT "
8432 "supported by target\n");
8433 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8438 fprintf_unfiltered (gdb_stdlog
,
8439 "binary downloading supported by target\n");
8440 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8447 /* Helper function to resize the payload in order to try to get a good
8448 alignment. We try to write an amount of data such that the next write will
8449 start on an address aligned on REMOTE_ALIGN_WRITES. */
8452 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8454 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8457 /* Write memory data directly to the remote machine.
8458 This does not inform the data cache; the data cache uses this.
8459 HEADER is the starting part of the packet.
8460 MEMADDR is the address in the remote memory space.
8461 MYADDR is the address of the buffer in our space.
8462 LEN_UNITS is the number of addressable units to write.
8463 UNIT_SIZE is the length in bytes of an addressable unit.
8464 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8465 should send data as binary ('X'), or hex-encoded ('M').
8467 The function creates packet of the form
8468 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8470 where encoding of <DATA> is terminated by PACKET_FORMAT.
8472 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8475 Return the transferred status, error or OK (an
8476 'enum target_xfer_status' value). Save the number of addressable units
8477 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8479 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8480 exchange between gdb and the stub could look like (?? in place of the
8486 -> $M1000,3:eeeeffffeeee#??
8490 <- eeeeffffeeeedddd */
8493 remote_target::remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8494 const gdb_byte
*myaddr
,
8497 ULONGEST
*xfered_len_units
,
8498 char packet_format
, int use_length
)
8500 struct remote_state
*rs
= get_remote_state ();
8506 int payload_capacity_bytes
;
8507 int payload_length_bytes
;
8509 if (packet_format
!= 'X' && packet_format
!= 'M')
8510 internal_error (__FILE__
, __LINE__
,
8511 _("remote_write_bytes_aux: bad packet format"));
8514 return TARGET_XFER_EOF
;
8516 payload_capacity_bytes
= get_memory_write_packet_size ();
8518 /* The packet buffer will be large enough for the payload;
8519 get_memory_packet_size ensures this. */
8522 /* Compute the size of the actual payload by subtracting out the
8523 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8525 payload_capacity_bytes
-= strlen ("$,:#NN");
8527 /* The comma won't be used. */
8528 payload_capacity_bytes
+= 1;
8529 payload_capacity_bytes
-= strlen (header
);
8530 payload_capacity_bytes
-= hexnumlen (memaddr
);
8532 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8534 strcat (rs
->buf
.data (), header
);
8535 p
= rs
->buf
.data () + strlen (header
);
8537 /* Compute a best guess of the number of bytes actually transfered. */
8538 if (packet_format
== 'X')
8540 /* Best guess at number of bytes that will fit. */
8541 todo_units
= std::min (len_units
,
8542 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8544 payload_capacity_bytes
-= hexnumlen (todo_units
);
8545 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8549 /* Number of bytes that will fit. */
8551 = std::min (len_units
,
8552 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8554 payload_capacity_bytes
-= hexnumlen (todo_units
);
8555 todo_units
= std::min (todo_units
,
8556 (payload_capacity_bytes
/ unit_size
) / 2);
8559 if (todo_units
<= 0)
8560 internal_error (__FILE__
, __LINE__
,
8561 _("minimum packet size too small to write data"));
8563 /* If we already need another packet, then try to align the end
8564 of this packet to a useful boundary. */
8565 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8566 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8568 /* Append "<memaddr>". */
8569 memaddr
= remote_address_masked (memaddr
);
8570 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8577 /* Append the length and retain its location and size. It may need to be
8578 adjusted once the packet body has been created. */
8580 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8588 /* Append the packet body. */
8589 if (packet_format
== 'X')
8591 /* Binary mode. Send target system values byte by byte, in
8592 increasing byte addresses. Only escape certain critical
8594 payload_length_bytes
=
8595 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8596 &units_written
, payload_capacity_bytes
);
8598 /* If not all TODO units fit, then we'll need another packet. Make
8599 a second try to keep the end of the packet aligned. Don't do
8600 this if the packet is tiny. */
8601 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8605 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8607 if (new_todo_units
!= units_written
)
8608 payload_length_bytes
=
8609 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8610 (gdb_byte
*) p
, &units_written
,
8611 payload_capacity_bytes
);
8614 p
+= payload_length_bytes
;
8615 if (use_length
&& units_written
< todo_units
)
8617 /* Escape chars have filled up the buffer prematurely,
8618 and we have actually sent fewer units than planned.
8619 Fix-up the length field of the packet. Use the same
8620 number of characters as before. */
8621 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8623 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8628 /* Normal mode: Send target system values byte by byte, in
8629 increasing byte addresses. Each byte is encoded as a two hex
8631 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8632 units_written
= todo_units
;
8635 putpkt_binary (rs
->buf
.data (), (int) (p
- rs
->buf
.data ()));
8636 getpkt (&rs
->buf
, 0);
8638 if (rs
->buf
[0] == 'E')
8639 return TARGET_XFER_E_IO
;
8641 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8642 send fewer units than we'd planned. */
8643 *xfered_len_units
= (ULONGEST
) units_written
;
8644 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8647 /* Write memory data directly to the remote machine.
8648 This does not inform the data cache; the data cache uses this.
8649 MEMADDR is the address in the remote memory space.
8650 MYADDR is the address of the buffer in our space.
8651 LEN is the number of bytes.
8653 Return the transferred status, error or OK (an
8654 'enum target_xfer_status' value). Save the number of bytes
8655 transferred in *XFERED_LEN. Only transfer a single packet. */
8658 remote_target::remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
8659 ULONGEST len
, int unit_size
,
8660 ULONGEST
*xfered_len
)
8662 const char *packet_format
= NULL
;
8664 /* Check whether the target supports binary download. */
8665 check_binary_download (memaddr
);
8667 switch (packet_support (PACKET_X
))
8670 packet_format
= "X";
8672 case PACKET_DISABLE
:
8673 packet_format
= "M";
8675 case PACKET_SUPPORT_UNKNOWN
:
8676 internal_error (__FILE__
, __LINE__
,
8677 _("remote_write_bytes: bad internal state"));
8679 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8682 return remote_write_bytes_aux (packet_format
,
8683 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8684 packet_format
[0], 1);
8687 /* Read memory data directly from the remote machine.
8688 This does not use the data cache; the data cache uses this.
8689 MEMADDR is the address in the remote memory space.
8690 MYADDR is the address of the buffer in our space.
8691 LEN_UNITS is the number of addressable memory units to read..
8692 UNIT_SIZE is the length in bytes of an addressable unit.
8694 Return the transferred status, error or OK (an
8695 'enum target_xfer_status' value). Save the number of bytes
8696 transferred in *XFERED_LEN_UNITS.
8698 See the comment of remote_write_bytes_aux for an example of
8699 memory read/write exchange between gdb and the stub. */
8702 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
8704 int unit_size
, ULONGEST
*xfered_len_units
)
8706 struct remote_state
*rs
= get_remote_state ();
8707 int buf_size_bytes
; /* Max size of packet output buffer. */
8712 buf_size_bytes
= get_memory_read_packet_size ();
8713 /* The packet buffer will be large enough for the payload;
8714 get_memory_packet_size ensures this. */
8716 /* Number of units that will fit. */
8717 todo_units
= std::min (len_units
,
8718 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8720 /* Construct "m"<memaddr>","<len>". */
8721 memaddr
= remote_address_masked (memaddr
);
8722 p
= rs
->buf
.data ();
8724 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8726 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8729 getpkt (&rs
->buf
, 0);
8730 if (rs
->buf
[0] == 'E'
8731 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8732 && rs
->buf
[3] == '\0')
8733 return TARGET_XFER_E_IO
;
8734 /* Reply describes memory byte by byte, each byte encoded as two hex
8736 p
= rs
->buf
.data ();
8737 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8738 /* Return what we have. Let higher layers handle partial reads. */
8739 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8740 return (*xfered_len_units
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
8743 /* Using the set of read-only target sections of remote, read live
8746 For interface/parameters/return description see target.h,
8750 remote_target::remote_xfer_live_readonly_partial (gdb_byte
*readbuf
,
8754 ULONGEST
*xfered_len
)
8756 struct target_section
*secp
;
8757 struct target_section_table
*table
;
8759 secp
= target_section_by_addr (this, memaddr
);
8761 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
8762 secp
->the_bfd_section
)
8765 struct target_section
*p
;
8766 ULONGEST memend
= memaddr
+ len
;
8768 table
= target_get_section_table (this);
8770 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8772 if (memaddr
>= p
->addr
)
8774 if (memend
<= p
->endaddr
)
8776 /* Entire transfer is within this section. */
8777 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8780 else if (memaddr
>= p
->endaddr
)
8782 /* This section ends before the transfer starts. */
8787 /* This section overlaps the transfer. Just do half. */
8788 len
= p
->endaddr
- memaddr
;
8789 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8796 return TARGET_XFER_EOF
;
8799 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8800 first if the requested memory is unavailable in traceframe.
8801 Otherwise, fall back to remote_read_bytes_1. */
8804 remote_target::remote_read_bytes (CORE_ADDR memaddr
,
8805 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8806 ULONGEST
*xfered_len
)
8809 return TARGET_XFER_EOF
;
8811 if (get_traceframe_number () != -1)
8813 std::vector
<mem_range
> available
;
8815 /* If we fail to get the set of available memory, then the
8816 target does not support querying traceframe info, and so we
8817 attempt reading from the traceframe anyway (assuming the
8818 target implements the old QTro packet then). */
8819 if (traceframe_available_memory (&available
, memaddr
, len
))
8821 if (available
.empty () || available
[0].start
!= memaddr
)
8823 enum target_xfer_status res
;
8825 /* Don't read into the traceframe's available
8827 if (!available
.empty ())
8829 LONGEST oldlen
= len
;
8831 len
= available
[0].start
- memaddr
;
8832 gdb_assert (len
<= oldlen
);
8835 /* This goes through the topmost target again. */
8836 res
= remote_xfer_live_readonly_partial (myaddr
, memaddr
,
8837 len
, unit_size
, xfered_len
);
8838 if (res
== TARGET_XFER_OK
)
8839 return TARGET_XFER_OK
;
8842 /* No use trying further, we know some memory starting
8843 at MEMADDR isn't available. */
8845 return (*xfered_len
!= 0) ?
8846 TARGET_XFER_UNAVAILABLE
: TARGET_XFER_EOF
;
8850 /* Don't try to read more than how much is available, in
8851 case the target implements the deprecated QTro packet to
8852 cater for older GDBs (the target's knowledge of read-only
8853 sections may be outdated by now). */
8854 len
= available
[0].length
;
8858 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8863 /* Sends a packet with content determined by the printf format string
8864 FORMAT and the remaining arguments, then gets the reply. Returns
8865 whether the packet was a success, a failure, or unknown. */
8868 remote_target::remote_send_printf (const char *format
, ...)
8870 struct remote_state
*rs
= get_remote_state ();
8871 int max_size
= get_remote_packet_size ();
8874 va_start (ap
, format
);
8877 int size
= vsnprintf (rs
->buf
.data (), max_size
, format
, ap
);
8881 if (size
>= max_size
)
8882 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8884 if (putpkt (rs
->buf
) < 0)
8885 error (_("Communication problem with target."));
8888 getpkt (&rs
->buf
, 0);
8890 return packet_check_result (rs
->buf
);
8893 /* Flash writing can take quite some time. We'll set
8894 effectively infinite timeout for flash operations.
8895 In future, we'll need to decide on a better approach. */
8896 static const int remote_flash_timeout
= 1000;
8899 remote_target::flash_erase (ULONGEST address
, LONGEST length
)
8901 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8902 enum packet_result ret
;
8903 scoped_restore restore_timeout
8904 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8906 ret
= remote_send_printf ("vFlashErase:%s,%s",
8907 phex (address
, addr_size
),
8911 case PACKET_UNKNOWN
:
8912 error (_("Remote target does not support flash erase"));
8914 error (_("Error erasing flash with vFlashErase packet"));
8921 remote_target::remote_flash_write (ULONGEST address
,
8922 ULONGEST length
, ULONGEST
*xfered_len
,
8923 const gdb_byte
*data
)
8925 scoped_restore restore_timeout
8926 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8927 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8932 remote_target::flash_done ()
8936 scoped_restore restore_timeout
8937 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8939 ret
= remote_send_printf ("vFlashDone");
8943 case PACKET_UNKNOWN
:
8944 error (_("Remote target does not support vFlashDone"));
8946 error (_("Error finishing flash operation"));
8953 remote_target::files_info ()
8955 puts_filtered ("Debugging a target over a serial line.\n");
8958 /* Stuff for dealing with the packets which are part of this protocol.
8959 See comment at top of file for details. */
8961 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8962 error to higher layers. Called when a serial error is detected.
8963 The exception message is STRING, followed by a colon and a blank,
8964 the system error message for errno at function entry and final dot
8965 for output compatibility with throw_perror_with_name. */
8968 unpush_and_perror (const char *string
)
8970 int saved_errno
= errno
;
8972 remote_unpush_target ();
8973 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8974 safe_strerror (saved_errno
));
8977 /* Read a single character from the remote end. The current quit
8978 handler is overridden to avoid quitting in the middle of packet
8979 sequence, as that would break communication with the remote server.
8980 See remote_serial_quit_handler for more detail. */
8983 remote_target::readchar (int timeout
)
8986 struct remote_state
*rs
= get_remote_state ();
8989 scoped_restore restore_quit_target
8990 = make_scoped_restore (&curr_quit_handler_target
, this);
8991 scoped_restore restore_quit
8992 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
8994 rs
->got_ctrlc_during_io
= 0;
8996 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8998 if (rs
->got_ctrlc_during_io
)
9005 switch ((enum serial_rc
) ch
)
9008 remote_unpush_target ();
9009 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
9012 unpush_and_perror (_("Remote communication error. "
9013 "Target disconnected."));
9015 case SERIAL_TIMEOUT
:
9021 /* Wrapper for serial_write that closes the target and throws if
9022 writing fails. The current quit handler is overridden to avoid
9023 quitting in the middle of packet sequence, as that would break
9024 communication with the remote server. See
9025 remote_serial_quit_handler for more detail. */
9028 remote_target::remote_serial_write (const char *str
, int len
)
9030 struct remote_state
*rs
= get_remote_state ();
9032 scoped_restore restore_quit_target
9033 = make_scoped_restore (&curr_quit_handler_target
, this);
9034 scoped_restore restore_quit
9035 = make_scoped_restore (&quit_handler
, ::remote_serial_quit_handler
);
9037 rs
->got_ctrlc_during_io
= 0;
9039 if (serial_write (rs
->remote_desc
, str
, len
))
9041 unpush_and_perror (_("Remote communication error. "
9042 "Target disconnected."));
9045 if (rs
->got_ctrlc_during_io
)
9049 /* Return a string representing an escaped version of BUF, of len N.
9050 E.g. \n is converted to \\n, \t to \\t, etc. */
9053 escape_buffer (const char *buf
, int n
)
9057 stb
.putstrn (buf
, n
, '\\');
9058 return std::move (stb
.string ());
9061 /* Display a null-terminated packet on stdout, for debugging, using C
9065 print_packet (const char *buf
)
9067 puts_filtered ("\"");
9068 fputstr_filtered (buf
, '"', gdb_stdout
);
9069 puts_filtered ("\"");
9073 remote_target::putpkt (const char *buf
)
9075 return putpkt_binary (buf
, strlen (buf
));
9078 /* Wrapper around remote_target::putpkt to avoid exporting
9082 putpkt (remote_target
*remote
, const char *buf
)
9084 return remote
->putpkt (buf
);
9087 /* Send a packet to the remote machine, with error checking. The data
9088 of the packet is in BUF. The string in BUF can be at most
9089 get_remote_packet_size () - 5 to account for the $, # and checksum,
9090 and for a possible /0 if we are debugging (remote_debug) and want
9091 to print the sent packet as a string. */
9094 remote_target::putpkt_binary (const char *buf
, int cnt
)
9096 struct remote_state
*rs
= get_remote_state ();
9098 unsigned char csum
= 0;
9099 gdb::def_vector
<char> data (cnt
+ 6);
9100 char *buf2
= data
.data ();
9106 /* Catch cases like trying to read memory or listing threads while
9107 we're waiting for a stop reply. The remote server wouldn't be
9108 ready to handle this request, so we'd hang and timeout. We don't
9109 have to worry about this in synchronous mode, because in that
9110 case it's not possible to issue a command while the target is
9111 running. This is not a problem in non-stop mode, because in that
9112 case, the stub is always ready to process serial input. */
9113 if (!target_is_non_stop_p ()
9114 && target_is_async_p ()
9115 && rs
->waiting_for_stop_reply
)
9117 error (_("Cannot execute this command while the target is running.\n"
9118 "Use the \"interrupt\" command to stop the target\n"
9119 "and then try again."));
9122 /* We're sending out a new packet. Make sure we don't look at a
9123 stale cached response. */
9124 rs
->cached_wait_status
= 0;
9126 /* Copy the packet into buffer BUF2, encapsulating it
9127 and giving it a checksum. */
9132 for (i
= 0; i
< cnt
; i
++)
9138 *p
++ = tohex ((csum
>> 4) & 0xf);
9139 *p
++ = tohex (csum
& 0xf);
9141 /* Send it over and over until we get a positive ack. */
9145 int started_error_output
= 0;
9151 int len
= (int) (p
- buf2
);
9154 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
9156 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
9158 if (len
> REMOTE_DEBUG_MAX_CHAR
)
9159 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9160 len
- REMOTE_DEBUG_MAX_CHAR
);
9162 fprintf_unfiltered (gdb_stdlog
, "...");
9164 gdb_flush (gdb_stdlog
);
9166 remote_serial_write (buf2
, p
- buf2
);
9168 /* If this is a no acks version of the remote protocol, send the
9169 packet and move on. */
9173 /* Read until either a timeout occurs (-2) or '+' is read.
9174 Handle any notification that arrives in the mean time. */
9177 ch
= readchar (remote_timeout
);
9185 case SERIAL_TIMEOUT
:
9188 if (started_error_output
)
9190 putchar_unfiltered ('\n');
9191 started_error_output
= 0;
9200 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
9204 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
9206 case SERIAL_TIMEOUT
:
9210 break; /* Retransmit buffer. */
9214 fprintf_unfiltered (gdb_stdlog
,
9215 "Packet instead of Ack, ignoring it\n");
9216 /* It's probably an old response sent because an ACK
9217 was lost. Gobble up the packet and ack it so it
9218 doesn't get retransmitted when we resend this
9221 remote_serial_write ("+", 1);
9222 continue; /* Now, go look for +. */
9229 /* If we got a notification, handle it, and go back to looking
9231 /* We've found the start of a notification. Now
9232 collect the data. */
9233 val
= read_frame (&rs
->buf
);
9238 std::string str
= escape_buffer (rs
->buf
.data (), val
);
9240 fprintf_unfiltered (gdb_stdlog
,
9241 " Notification received: %s\n",
9244 handle_notification (rs
->notif_state
, rs
->buf
.data ());
9245 /* We're in sync now, rewait for the ack. */
9252 if (!started_error_output
)
9254 started_error_output
= 1;
9255 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9257 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9258 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
.data ());
9267 if (!started_error_output
)
9269 started_error_output
= 1;
9270 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
9272 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
9276 break; /* Here to retransmit. */
9280 /* This is wrong. If doing a long backtrace, the user should be
9281 able to get out next time we call QUIT, without anything as
9282 violent as interrupt_query. If we want to provide a way out of
9283 here without getting to the next QUIT, it should be based on
9284 hitting ^C twice as in remote_wait. */
9296 /* Come here after finding the start of a frame when we expected an
9297 ack. Do our best to discard the rest of this packet. */
9300 remote_target::skip_frame ()
9306 c
= readchar (remote_timeout
);
9309 case SERIAL_TIMEOUT
:
9310 /* Nothing we can do. */
9313 /* Discard the two bytes of checksum and stop. */
9314 c
= readchar (remote_timeout
);
9316 c
= readchar (remote_timeout
);
9319 case '*': /* Run length encoding. */
9320 /* Discard the repeat count. */
9321 c
= readchar (remote_timeout
);
9326 /* A regular character. */
9332 /* Come here after finding the start of the frame. Collect the rest
9333 into *BUF, verifying the checksum, length, and handling run-length
9334 compression. NUL terminate the buffer. If there is not enough room,
9337 Returns -1 on error, number of characters in buffer (ignoring the
9338 trailing NULL) on success. (could be extended to return one of the
9339 SERIAL status indications). */
9342 remote_target::read_frame (gdb::char_vector
*buf_p
)
9347 char *buf
= buf_p
->data ();
9348 struct remote_state
*rs
= get_remote_state ();
9355 c
= readchar (remote_timeout
);
9358 case SERIAL_TIMEOUT
:
9360 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
9364 fputs_filtered ("Saw new packet start in middle of old one\n",
9366 return -1; /* Start a new packet, count retries. */
9369 unsigned char pktcsum
;
9375 check_0
= readchar (remote_timeout
);
9377 check_1
= readchar (remote_timeout
);
9379 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9382 fputs_filtered ("Timeout in checksum, retrying\n",
9386 else if (check_0
< 0 || check_1
< 0)
9389 fputs_filtered ("Communication error in checksum\n",
9394 /* Don't recompute the checksum; with no ack packets we
9395 don't have any way to indicate a packet retransmission
9400 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9401 if (csum
== pktcsum
)
9406 std::string str
= escape_buffer (buf
, bc
);
9408 fprintf_unfiltered (gdb_stdlog
,
9409 "Bad checksum, sentsum=0x%x, "
9410 "csum=0x%x, buf=%s\n",
9411 pktcsum
, csum
, str
.c_str ());
9413 /* Number of characters in buffer ignoring trailing
9417 case '*': /* Run length encoding. */
9422 c
= readchar (remote_timeout
);
9424 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9426 /* The character before ``*'' is repeated. */
9428 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9430 if (bc
+ repeat
- 1 >= buf_p
->size () - 1)
9432 /* Make some more room in the buffer. */
9433 buf_p
->resize (buf_p
->size () + repeat
);
9434 buf
= buf_p
->data ();
9437 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9443 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9447 if (bc
>= buf_p
->size () - 1)
9449 /* Make some more room in the buffer. */
9450 buf_p
->resize (buf_p
->size () * 2);
9451 buf
= buf_p
->data ();
9461 /* Read a packet from the remote machine, with error checking, and
9462 store it in *BUF. Resize *BUF if necessary to hold the result. If
9463 FOREVER, wait forever rather than timing out; this is used (in
9464 synchronous mode) to wait for a target that is is executing user
9466 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9467 don't have to change all the calls to getpkt to deal with the
9468 return value, because at the moment I don't know what the right
9469 thing to do it for those. */
9472 remote_target::getpkt (gdb::char_vector
*buf
, int forever
)
9474 getpkt_sane (buf
, forever
);
9478 /* Read a packet from the remote machine, with error checking, and
9479 store it in *BUF. Resize *BUF if necessary to hold the result. If
9480 FOREVER, wait forever rather than timing out; this is used (in
9481 synchronous mode) to wait for a target that is is executing user
9482 code to stop. If FOREVER == 0, this function is allowed to time
9483 out gracefully and return an indication of this to the caller.
9484 Otherwise return the number of bytes read. If EXPECTING_NOTIF,
9485 consider receiving a notification enough reason to return to the
9486 caller. *IS_NOTIF is an output boolean that indicates whether *BUF
9487 holds a notification or not (a regular packet). */
9490 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector
*buf
,
9491 int forever
, int expecting_notif
,
9494 struct remote_state
*rs
= get_remote_state ();
9500 /* We're reading a new response. Make sure we don't look at a
9501 previously cached response. */
9502 rs
->cached_wait_status
= 0;
9504 strcpy (buf
->data (), "timeout");
9507 timeout
= watchdog
> 0 ? watchdog
: -1;
9508 else if (expecting_notif
)
9509 timeout
= 0; /* There should already be a char in the buffer. If
9512 timeout
= remote_timeout
;
9516 /* Process any number of notifications, and then return when
9520 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9522 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9524 /* This can loop forever if the remote side sends us
9525 characters continuously, but if it pauses, we'll get
9526 SERIAL_TIMEOUT from readchar because of timeout. Then
9527 we'll count that as a retry.
9529 Note that even when forever is set, we will only wait
9530 forever prior to the start of a packet. After that, we
9531 expect characters to arrive at a brisk pace. They should
9532 show up within remote_timeout intervals. */
9534 c
= readchar (timeout
);
9535 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9537 if (c
== SERIAL_TIMEOUT
)
9539 if (expecting_notif
)
9540 return -1; /* Don't complain, it's normal to not get
9541 anything in this case. */
9543 if (forever
) /* Watchdog went off? Kill the target. */
9545 remote_unpush_target ();
9546 throw_error (TARGET_CLOSE_ERROR
,
9547 _("Watchdog timeout has expired. "
9548 "Target detached."));
9551 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9555 /* We've found the start of a packet or notification.
9556 Now collect the data. */
9557 val
= read_frame (buf
);
9562 remote_serial_write ("-", 1);
9565 if (tries
> MAX_TRIES
)
9567 /* We have tried hard enough, and just can't receive the
9568 packet/notification. Give up. */
9569 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9571 /* Skip the ack char if we're in no-ack mode. */
9572 if (!rs
->noack_mode
)
9573 remote_serial_write ("+", 1);
9577 /* If we got an ordinary packet, return that to our caller. */
9583 = escape_buffer (buf
->data (),
9584 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9586 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9589 if (val
> REMOTE_DEBUG_MAX_CHAR
)
9590 fprintf_unfiltered (gdb_stdlog
, "[%d bytes omitted]",
9591 val
- REMOTE_DEBUG_MAX_CHAR
);
9593 fprintf_unfiltered (gdb_stdlog
, "\n");
9596 /* Skip the ack char if we're in no-ack mode. */
9597 if (!rs
->noack_mode
)
9598 remote_serial_write ("+", 1);
9599 if (is_notif
!= NULL
)
9604 /* If we got a notification, handle it, and go back to looking
9608 gdb_assert (c
== '%');
9612 std::string str
= escape_buffer (buf
->data (), val
);
9614 fprintf_unfiltered (gdb_stdlog
,
9615 " Notification received: %s\n",
9618 if (is_notif
!= NULL
)
9621 handle_notification (rs
->notif_state
, buf
->data ());
9623 /* Notifications require no acknowledgement. */
9625 if (expecting_notif
)
9632 remote_target::getpkt_sane (gdb::char_vector
*buf
, int forever
)
9634 return getpkt_or_notif_sane_1 (buf
, forever
, 0, NULL
);
9638 remote_target::getpkt_or_notif_sane (gdb::char_vector
*buf
, int forever
,
9641 return getpkt_or_notif_sane_1 (buf
, forever
, 1, is_notif
);
9644 /* Kill any new fork children of process PID that haven't been
9645 processed by follow_fork. */
9648 remote_target::kill_new_fork_children (int pid
)
9650 remote_state
*rs
= get_remote_state ();
9651 struct notif_client
*notif
= ¬if_client_stop
;
9653 /* Kill the fork child threads of any threads in process PID
9654 that are stopped at a fork event. */
9655 for (thread_info
*thread
: all_non_exited_threads ())
9657 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9659 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9661 int child_pid
= ws
->value
.related_pid
.pid ();
9664 res
= remote_vkill (child_pid
);
9666 error (_("Can't kill fork child process %d"), child_pid
);
9670 /* Check for any pending fork events (not reported or processed yet)
9671 in process PID and kill those fork child threads as well. */
9672 remote_notif_get_pending_events (notif
);
9673 for (auto &event
: rs
->stop_reply_queue
)
9674 if (is_pending_fork_parent (&event
->ws
, pid
, event
->ptid
))
9676 int child_pid
= event
->ws
.value
.related_pid
.pid ();
9679 res
= remote_vkill (child_pid
);
9681 error (_("Can't kill fork child process %d"), child_pid
);
9686 /* Target hook to kill the current inferior. */
9689 remote_target::kill ()
9692 int pid
= inferior_ptid
.pid ();
9693 struct remote_state
*rs
= get_remote_state ();
9695 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9697 /* If we're stopped while forking and we haven't followed yet,
9698 kill the child task. We need to do this before killing the
9699 parent task because if this is a vfork then the parent will
9701 kill_new_fork_children (pid
);
9703 res
= remote_vkill (pid
);
9706 target_mourn_inferior (inferior_ptid
);
9711 /* If we are in 'target remote' mode and we are killing the only
9712 inferior, then we will tell gdbserver to exit and unpush the
9714 if (res
== -1 && !remote_multi_process_p (rs
)
9715 && number_of_live_inferiors () == 1)
9719 /* We've killed the remote end, we get to mourn it. If we are
9720 not in extended mode, mourning the inferior also unpushes
9721 remote_ops from the target stack, which closes the remote
9723 target_mourn_inferior (inferior_ptid
);
9728 error (_("Can't kill process"));
9731 /* Send a kill request to the target using the 'vKill' packet. */
9734 remote_target::remote_vkill (int pid
)
9736 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9739 remote_state
*rs
= get_remote_state ();
9741 /* Tell the remote target to detach. */
9742 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "vKill;%x", pid
);
9744 getpkt (&rs
->buf
, 0);
9746 switch (packet_ok (rs
->buf
,
9747 &remote_protocol_packets
[PACKET_vKill
]))
9753 case PACKET_UNKNOWN
:
9756 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9760 /* Send a kill request to the target using the 'k' packet. */
9763 remote_target::remote_kill_k ()
9765 /* Catch errors so the user can quit from gdb even when we
9766 aren't on speaking terms with the remote system. */
9771 catch (const gdb_exception_error
&ex
)
9773 if (ex
.error
== TARGET_CLOSE_ERROR
)
9775 /* If we got an (EOF) error that caused the target
9776 to go away, then we're done, that's what we wanted.
9777 "k" is susceptible to cause a premature EOF, given
9778 that the remote server isn't actually required to
9779 reply to "k", and it can happen that it doesn't
9780 even get to reply ACK to the "k". */
9784 /* Otherwise, something went wrong. We didn't actually kill
9785 the target. Just propagate the exception, and let the
9786 user or higher layers decide what to do. */
9792 remote_target::mourn_inferior ()
9794 struct remote_state
*rs
= get_remote_state ();
9796 /* We're no longer interested in notification events of an inferior
9797 that exited or was killed/detached. */
9798 discard_pending_stop_replies (current_inferior ());
9800 /* In 'target remote' mode with one inferior, we close the connection. */
9801 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9803 unpush_target (this);
9805 /* remote_close takes care of doing most of the clean up. */
9806 generic_mourn_inferior ();
9810 /* In case we got here due to an error, but we're going to stay
9812 rs
->waiting_for_stop_reply
= 0;
9814 /* If the current general thread belonged to the process we just
9815 detached from or has exited, the remote side current general
9816 thread becomes undefined. Considering a case like this:
9818 - We just got here due to a detach.
9819 - The process that we're detaching from happens to immediately
9820 report a global breakpoint being hit in non-stop mode, in the
9821 same thread we had selected before.
9822 - GDB attaches to this process again.
9823 - This event happens to be the next event we handle.
9825 GDB would consider that the current general thread didn't need to
9826 be set on the stub side (with Hg), since for all it knew,
9827 GENERAL_THREAD hadn't changed.
9829 Notice that although in all-stop mode, the remote server always
9830 sets the current thread to the thread reporting the stop event,
9831 that doesn't happen in non-stop mode; in non-stop, the stub *must
9832 not* change the current thread when reporting a breakpoint hit,
9833 due to the decoupling of event reporting and event handling.
9835 To keep things simple, we always invalidate our notion of the
9837 record_currthread (rs
, minus_one_ptid
);
9839 /* Call common code to mark the inferior as not running. */
9840 generic_mourn_inferior ();
9842 if (!have_inferiors ())
9844 if (!remote_multi_process_p (rs
))
9846 /* Check whether the target is running now - some remote stubs
9847 automatically restart after kill. */
9849 getpkt (&rs
->buf
, 0);
9851 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9853 /* Assume that the target has been restarted. Set
9854 inferior_ptid so that bits of core GDB realizes
9855 there's something here, e.g., so that the user can
9856 say "kill" again. */
9857 inferior_ptid
= magic_null_ptid
;
9864 extended_remote_target::supports_disable_randomization ()
9866 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9870 remote_target::extended_remote_disable_randomization (int val
)
9872 struct remote_state
*rs
= get_remote_state ();
9875 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9876 "QDisableRandomization:%x", val
);
9878 reply
= remote_get_noisy_reply ();
9880 error (_("Target does not support QDisableRandomization."));
9881 if (strcmp (reply
, "OK") != 0)
9882 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9886 remote_target::extended_remote_run (const std::string
&args
)
9888 struct remote_state
*rs
= get_remote_state ();
9890 const char *remote_exec_file
= get_remote_exec_file ();
9892 /* If the user has disabled vRun support, or we have detected that
9893 support is not available, do not try it. */
9894 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9897 strcpy (rs
->buf
.data (), "vRun;");
9898 len
= strlen (rs
->buf
.data ());
9900 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9901 error (_("Remote file name too long for run packet"));
9902 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
.data () + len
,
9903 strlen (remote_exec_file
));
9909 gdb_argv
argv (args
.c_str ());
9910 for (i
= 0; argv
[i
] != NULL
; i
++)
9912 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9913 error (_("Argument list too long for run packet"));
9914 rs
->buf
[len
++] = ';';
9915 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
.data () + len
,
9920 rs
->buf
[len
++] = '\0';
9923 getpkt (&rs
->buf
, 0);
9925 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9928 /* We have a wait response. All is well. */
9930 case PACKET_UNKNOWN
:
9933 if (remote_exec_file
[0] == '\0')
9934 error (_("Running the default executable on the remote target failed; "
9935 "try \"set remote exec-file\"?"));
9937 error (_("Running \"%s\" on the remote target failed"),
9940 gdb_assert_not_reached (_("bad switch"));
9944 /* Helper function to send set/unset environment packets. ACTION is
9945 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9946 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9950 remote_target::send_environment_packet (const char *action
,
9954 remote_state
*rs
= get_remote_state ();
9956 /* Convert the environment variable to an hex string, which
9957 is the best format to be transmitted over the wire. */
9958 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9961 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
9962 "%s:%s", packet
, encoded_value
.c_str ());
9965 getpkt (&rs
->buf
, 0);
9966 if (strcmp (rs
->buf
.data (), "OK") != 0)
9967 warning (_("Unable to %s environment variable '%s' on remote."),
9971 /* Helper function to handle the QEnvironment* packets. */
9974 remote_target::extended_remote_environment_support ()
9976 remote_state
*rs
= get_remote_state ();
9978 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9980 putpkt ("QEnvironmentReset");
9981 getpkt (&rs
->buf
, 0);
9982 if (strcmp (rs
->buf
.data (), "OK") != 0)
9983 warning (_("Unable to reset environment on remote."));
9986 gdb_environ
*e
= ¤t_inferior ()->environment
;
9988 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9989 for (const std::string
&el
: e
->user_set_env ())
9990 send_environment_packet ("set", "QEnvironmentHexEncoded",
9993 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
9994 for (const std::string
&el
: e
->user_unset_env ())
9995 send_environment_packet ("unset", "QEnvironmentUnset", el
.c_str ());
9998 /* Helper function to set the current working directory for the
9999 inferior in the remote target. */
10002 remote_target::extended_remote_set_inferior_cwd ()
10004 if (packet_support (PACKET_QSetWorkingDir
) != PACKET_DISABLE
)
10006 const char *inferior_cwd
= get_inferior_cwd ();
10007 remote_state
*rs
= get_remote_state ();
10009 if (inferior_cwd
!= NULL
)
10011 std::string hexpath
= bin2hex ((const gdb_byte
*) inferior_cwd
,
10012 strlen (inferior_cwd
));
10014 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10015 "QSetWorkingDir:%s", hexpath
.c_str ());
10019 /* An empty inferior_cwd means that the user wants us to
10020 reset the remote server's inferior's cwd. */
10021 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10022 "QSetWorkingDir:");
10026 getpkt (&rs
->buf
, 0);
10027 if (packet_ok (rs
->buf
,
10028 &remote_protocol_packets
[PACKET_QSetWorkingDir
])
10031 Remote replied unexpectedly while setting the inferior's working\n\
10038 /* In the extended protocol we want to be able to do things like
10039 "run" and have them basically work as expected. So we need
10040 a special create_inferior function. We support changing the
10041 executable file and the command line arguments, but not the
10045 extended_remote_target::create_inferior (const char *exec_file
,
10046 const std::string
&args
,
10047 char **env
, int from_tty
)
10051 struct remote_state
*rs
= get_remote_state ();
10052 const char *remote_exec_file
= get_remote_exec_file ();
10054 /* If running asynchronously, register the target file descriptor
10055 with the event loop. */
10056 if (target_can_async_p ())
10059 /* Disable address space randomization if requested (and supported). */
10060 if (supports_disable_randomization ())
10061 extended_remote_disable_randomization (disable_randomization
);
10063 /* If startup-with-shell is on, we inform gdbserver to start the
10064 remote inferior using a shell. */
10065 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
10067 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
10068 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
10070 getpkt (&rs
->buf
, 0);
10071 if (strcmp (rs
->buf
.data (), "OK") != 0)
10073 Remote replied unexpectedly while setting startup-with-shell: %s"),
10077 extended_remote_environment_support ();
10079 extended_remote_set_inferior_cwd ();
10081 /* Now restart the remote server. */
10082 run_worked
= extended_remote_run (args
) != -1;
10085 /* vRun was not supported. Fail if we need it to do what the
10087 if (remote_exec_file
[0])
10088 error (_("Remote target does not support \"set remote exec-file\""));
10089 if (!args
.empty ())
10090 error (_("Remote target does not support \"set args\" or run ARGS"));
10092 /* Fall back to "R". */
10093 extended_remote_restart ();
10096 /* vRun's success return is a stop reply. */
10097 stop_reply
= run_worked
? rs
->buf
.data () : NULL
;
10098 add_current_inferior_and_thread (stop_reply
);
10100 /* Get updated offsets, if the stub uses qOffsets. */
10105 /* Given a location's target info BP_TGT and the packet buffer BUF, output
10106 the list of conditions (in agent expression bytecode format), if any, the
10107 target needs to evaluate. The output is placed into the packet buffer
10108 started from BUF and ended at BUF_END. */
10111 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
10112 struct bp_target_info
*bp_tgt
, char *buf
,
10115 if (bp_tgt
->conditions
.empty ())
10118 buf
+= strlen (buf
);
10119 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
10122 /* Send conditions to the target. */
10123 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
10125 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
10126 buf
+= strlen (buf
);
10127 for (int i
= 0; i
< aexpr
->len
; ++i
)
10128 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10135 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
10136 struct bp_target_info
*bp_tgt
, char *buf
)
10138 if (bp_tgt
->tcommands
.empty ())
10141 buf
+= strlen (buf
);
10143 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
10144 buf
+= strlen (buf
);
10146 /* Concatenate all the agent expressions that are commands into the
10148 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
10150 sprintf (buf
, "X%x,", aexpr
->len
);
10151 buf
+= strlen (buf
);
10152 for (int i
= 0; i
< aexpr
->len
; ++i
)
10153 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
10158 /* Insert a breakpoint. On targets that have software breakpoint
10159 support, we ask the remote target to do the work; on targets
10160 which don't, we insert a traditional memory breakpoint. */
10163 remote_target::insert_breakpoint (struct gdbarch
*gdbarch
,
10164 struct bp_target_info
*bp_tgt
)
10166 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10167 If it succeeds, then set the support to PACKET_ENABLE. If it
10168 fails, and the user has explicitly requested the Z support then
10169 report an error, otherwise, mark it disabled and go on. */
10171 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10173 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10174 struct remote_state
*rs
;
10177 /* Make sure the remote is pointing at the right process, if
10179 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10180 set_general_process ();
10182 rs
= get_remote_state ();
10183 p
= rs
->buf
.data ();
10184 endbuf
= p
+ get_remote_packet_size ();
10189 addr
= (ULONGEST
) remote_address_masked (addr
);
10190 p
+= hexnumstr (p
, addr
);
10191 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10193 if (supports_evaluation_of_breakpoint_conditions ())
10194 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10196 if (can_run_breakpoint_commands ())
10197 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10200 getpkt (&rs
->buf
, 0);
10202 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
10208 case PACKET_UNKNOWN
:
10213 /* If this breakpoint has target-side commands but this stub doesn't
10214 support Z0 packets, throw error. */
10215 if (!bp_tgt
->tcommands
.empty ())
10216 throw_error (NOT_SUPPORTED_ERROR
, _("\
10217 Target doesn't support breakpoints that have target side commands."));
10219 return memory_insert_breakpoint (this, gdbarch
, bp_tgt
);
10223 remote_target::remove_breakpoint (struct gdbarch
*gdbarch
,
10224 struct bp_target_info
*bp_tgt
,
10225 enum remove_bp_reason reason
)
10227 CORE_ADDR addr
= bp_tgt
->placed_address
;
10228 struct remote_state
*rs
= get_remote_state ();
10230 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
10232 char *p
= rs
->buf
.data ();
10233 char *endbuf
= p
+ get_remote_packet_size ();
10235 /* Make sure the remote is pointing at the right process, if
10237 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10238 set_general_process ();
10244 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
10245 p
+= hexnumstr (p
, addr
);
10246 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
10249 getpkt (&rs
->buf
, 0);
10251 return (rs
->buf
[0] == 'E');
10254 return memory_remove_breakpoint (this, gdbarch
, bp_tgt
, reason
);
10257 static enum Z_packet_type
10258 watchpoint_to_Z_packet (int type
)
10263 return Z_PACKET_WRITE_WP
;
10266 return Z_PACKET_READ_WP
;
10269 return Z_PACKET_ACCESS_WP
;
10272 internal_error (__FILE__
, __LINE__
,
10273 _("hw_bp_to_z: bad watchpoint type %d"), type
);
10278 remote_target::insert_watchpoint (CORE_ADDR addr
, int len
,
10279 enum target_hw_bp_type type
, struct expression
*cond
)
10281 struct remote_state
*rs
= get_remote_state ();
10282 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10284 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10286 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10289 /* Make sure the remote is pointing at the right process, if
10291 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10292 set_general_process ();
10294 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "Z%x,", packet
);
10295 p
= strchr (rs
->buf
.data (), '\0');
10296 addr
= remote_address_masked (addr
);
10297 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10298 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10301 getpkt (&rs
->buf
, 0);
10303 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10307 case PACKET_UNKNOWN
:
10312 internal_error (__FILE__
, __LINE__
,
10313 _("remote_insert_watchpoint: reached end of function"));
10317 remote_target::watchpoint_addr_within_range (CORE_ADDR addr
,
10318 CORE_ADDR start
, int length
)
10320 CORE_ADDR diff
= remote_address_masked (addr
- start
);
10322 return diff
< length
;
10327 remote_target::remove_watchpoint (CORE_ADDR addr
, int len
,
10328 enum target_hw_bp_type type
, struct expression
*cond
)
10330 struct remote_state
*rs
= get_remote_state ();
10331 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
10333 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
10335 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
10338 /* Make sure the remote is pointing at the right process, if
10340 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10341 set_general_process ();
10343 xsnprintf (rs
->buf
.data (), endbuf
- rs
->buf
.data (), "z%x,", packet
);
10344 p
= strchr (rs
->buf
.data (), '\0');
10345 addr
= remote_address_masked (addr
);
10346 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10347 xsnprintf (p
, endbuf
- p
, ",%x", len
);
10349 getpkt (&rs
->buf
, 0);
10351 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
10354 case PACKET_UNKNOWN
:
10359 internal_error (__FILE__
, __LINE__
,
10360 _("remote_remove_watchpoint: reached end of function"));
10364 int remote_hw_watchpoint_limit
= -1;
10365 int remote_hw_watchpoint_length_limit
= -1;
10366 int remote_hw_breakpoint_limit
= -1;
10369 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
10371 if (remote_hw_watchpoint_length_limit
== 0)
10373 else if (remote_hw_watchpoint_length_limit
< 0)
10375 else if (len
<= remote_hw_watchpoint_length_limit
)
10382 remote_target::can_use_hw_breakpoint (enum bptype type
, int cnt
, int ot
)
10384 if (type
== bp_hardware_breakpoint
)
10386 if (remote_hw_breakpoint_limit
== 0)
10388 else if (remote_hw_breakpoint_limit
< 0)
10390 else if (cnt
<= remote_hw_breakpoint_limit
)
10395 if (remote_hw_watchpoint_limit
== 0)
10397 else if (remote_hw_watchpoint_limit
< 0)
10401 else if (cnt
<= remote_hw_watchpoint_limit
)
10407 /* The to_stopped_by_sw_breakpoint method of target remote. */
10410 remote_target::stopped_by_sw_breakpoint ()
10412 struct thread_info
*thread
= inferior_thread ();
10414 return (thread
->priv
!= NULL
10415 && (get_remote_thread_info (thread
)->stop_reason
10416 == TARGET_STOPPED_BY_SW_BREAKPOINT
));
10419 /* The to_supports_stopped_by_sw_breakpoint method of target
10423 remote_target::supports_stopped_by_sw_breakpoint ()
10425 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10428 /* The to_stopped_by_hw_breakpoint method of target remote. */
10431 remote_target::stopped_by_hw_breakpoint ()
10433 struct thread_info
*thread
= inferior_thread ();
10435 return (thread
->priv
!= NULL
10436 && (get_remote_thread_info (thread
)->stop_reason
10437 == TARGET_STOPPED_BY_HW_BREAKPOINT
));
10440 /* The to_supports_stopped_by_hw_breakpoint method of target
10444 remote_target::supports_stopped_by_hw_breakpoint ()
10446 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10450 remote_target::stopped_by_watchpoint ()
10452 struct thread_info
*thread
= inferior_thread ();
10454 return (thread
->priv
!= NULL
10455 && (get_remote_thread_info (thread
)->stop_reason
10456 == TARGET_STOPPED_BY_WATCHPOINT
));
10460 remote_target::stopped_data_address (CORE_ADDR
*addr_p
)
10462 struct thread_info
*thread
= inferior_thread ();
10464 if (thread
->priv
!= NULL
10465 && (get_remote_thread_info (thread
)->stop_reason
10466 == TARGET_STOPPED_BY_WATCHPOINT
))
10468 *addr_p
= get_remote_thread_info (thread
)->watch_data_address
;
10477 remote_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
10478 struct bp_target_info
*bp_tgt
)
10480 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10481 struct remote_state
*rs
;
10485 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10488 /* Make sure the remote is pointing at the right process, if
10490 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10491 set_general_process ();
10493 rs
= get_remote_state ();
10494 p
= rs
->buf
.data ();
10495 endbuf
= p
+ get_remote_packet_size ();
10501 addr
= remote_address_masked (addr
);
10502 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10503 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10505 if (supports_evaluation_of_breakpoint_conditions ())
10506 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10508 if (can_run_breakpoint_commands ())
10509 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10512 getpkt (&rs
->buf
, 0);
10514 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10517 if (rs
->buf
[1] == '.')
10519 message
= strchr (&rs
->buf
[2], '.');
10521 error (_("Remote failure reply: %s"), message
+ 1);
10524 case PACKET_UNKNOWN
:
10529 internal_error (__FILE__
, __LINE__
,
10530 _("remote_insert_hw_breakpoint: reached end of function"));
10535 remote_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
10536 struct bp_target_info
*bp_tgt
)
10539 struct remote_state
*rs
= get_remote_state ();
10540 char *p
= rs
->buf
.data ();
10541 char *endbuf
= p
+ get_remote_packet_size ();
10543 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10546 /* Make sure the remote is pointing at the right process, if
10548 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10549 set_general_process ();
10555 addr
= remote_address_masked (bp_tgt
->placed_address
);
10556 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10557 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10560 getpkt (&rs
->buf
, 0);
10562 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10565 case PACKET_UNKNOWN
:
10570 internal_error (__FILE__
, __LINE__
,
10571 _("remote_remove_hw_breakpoint: reached end of function"));
10574 /* Verify memory using the "qCRC:" request. */
10577 remote_target::verify_memory (const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10579 struct remote_state
*rs
= get_remote_state ();
10580 unsigned long host_crc
, target_crc
;
10583 /* It doesn't make sense to use qCRC if the remote target is
10584 connected but not running. */
10585 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10587 enum packet_result result
;
10589 /* Make sure the remote is pointing at the right process. */
10590 set_general_process ();
10592 /* FIXME: assumes lma can fit into long. */
10593 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10594 (long) lma
, (long) size
);
10597 /* Be clever; compute the host_crc before waiting for target
10599 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10601 getpkt (&rs
->buf
, 0);
10603 result
= packet_ok (rs
->buf
,
10604 &remote_protocol_packets
[PACKET_qCRC
]);
10605 if (result
== PACKET_ERROR
)
10607 else if (result
== PACKET_OK
)
10609 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10610 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10612 return (host_crc
== target_crc
);
10616 return simple_verify_memory (this, data
, lma
, size
);
10619 /* compare-sections command
10621 With no arguments, compares each loadable section in the exec bfd
10622 with the same memory range on the target, and reports mismatches.
10623 Useful for verifying the image on the target against the exec file. */
10626 compare_sections_command (const char *args
, int from_tty
)
10629 const char *sectname
;
10630 bfd_size_type size
;
10633 int mismatched
= 0;
10638 error (_("command cannot be used without an exec file"));
10640 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10646 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10648 if (!(s
->flags
& SEC_LOAD
))
10649 continue; /* Skip non-loadable section. */
10651 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10652 continue; /* Skip writeable sections */
10654 size
= bfd_get_section_size (s
);
10656 continue; /* Skip zero-length section. */
10658 sectname
= bfd_get_section_name (exec_bfd
, s
);
10659 if (args
&& strcmp (args
, sectname
) != 0)
10660 continue; /* Not the section selected by user. */
10662 matched
= 1; /* Do this section. */
10665 gdb::byte_vector
sectdata (size
);
10666 bfd_get_section_contents (exec_bfd
, s
, sectdata
.data (), 0, size
);
10668 res
= target_verify_memory (sectdata
.data (), lma
, size
);
10671 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10672 paddress (target_gdbarch (), lma
),
10673 paddress (target_gdbarch (), lma
+ size
));
10675 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10676 paddress (target_gdbarch (), lma
),
10677 paddress (target_gdbarch (), lma
+ size
));
10679 printf_filtered ("matched.\n");
10682 printf_filtered ("MIS-MATCHED!\n");
10686 if (mismatched
> 0)
10687 warning (_("One or more sections of the target image does not match\n\
10688 the loaded file\n"));
10689 if (args
&& !matched
)
10690 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10693 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10694 into remote target. The number of bytes written to the remote
10695 target is returned, or -1 for error. */
10698 remote_target::remote_write_qxfer (const char *object_name
,
10699 const char *annex
, const gdb_byte
*writebuf
,
10700 ULONGEST offset
, LONGEST len
,
10701 ULONGEST
*xfered_len
,
10702 struct packet_config
*packet
)
10706 struct remote_state
*rs
= get_remote_state ();
10707 int max_size
= get_memory_write_packet_size ();
10709 if (packet_config_support (packet
) == PACKET_DISABLE
)
10710 return TARGET_XFER_E_IO
;
10712 /* Insert header. */
10713 i
= snprintf (rs
->buf
.data (), max_size
,
10714 "qXfer:%s:write:%s:%s:",
10715 object_name
, annex
? annex
: "",
10716 phex_nz (offset
, sizeof offset
));
10717 max_size
-= (i
+ 1);
10719 /* Escape as much data as fits into rs->buf. */
10720 buf_len
= remote_escape_output
10721 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
.data () + i
, &max_size
, max_size
);
10723 if (putpkt_binary (rs
->buf
.data (), i
+ buf_len
) < 0
10724 || getpkt_sane (&rs
->buf
, 0) < 0
10725 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10726 return TARGET_XFER_E_IO
;
10728 unpack_varlen_hex (rs
->buf
.data (), &n
);
10731 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
10734 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10735 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10736 number of bytes read is returned, or 0 for EOF, or -1 for error.
10737 The number of bytes read may be less than LEN without indicating an
10738 EOF. PACKET is checked and updated to indicate whether the remote
10739 target supports this object. */
10742 remote_target::remote_read_qxfer (const char *object_name
,
10744 gdb_byte
*readbuf
, ULONGEST offset
,
10746 ULONGEST
*xfered_len
,
10747 struct packet_config
*packet
)
10749 struct remote_state
*rs
= get_remote_state ();
10750 LONGEST i
, n
, packet_len
;
10752 if (packet_config_support (packet
) == PACKET_DISABLE
)
10753 return TARGET_XFER_E_IO
;
10755 /* Check whether we've cached an end-of-object packet that matches
10757 if (rs
->finished_object
)
10759 if (strcmp (object_name
, rs
->finished_object
) == 0
10760 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10761 && offset
== rs
->finished_offset
)
10762 return TARGET_XFER_EOF
;
10765 /* Otherwise, we're now reading something different. Discard
10767 xfree (rs
->finished_object
);
10768 xfree (rs
->finished_annex
);
10769 rs
->finished_object
= NULL
;
10770 rs
->finished_annex
= NULL
;
10773 /* Request only enough to fit in a single packet. The actual data
10774 may not, since we don't know how much of it will need to be escaped;
10775 the target is free to respond with slightly less data. We subtract
10776 five to account for the response type and the protocol frame. */
10777 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10778 snprintf (rs
->buf
.data (), get_remote_packet_size () - 4,
10779 "qXfer:%s:read:%s:%s,%s",
10780 object_name
, annex
? annex
: "",
10781 phex_nz (offset
, sizeof offset
),
10782 phex_nz (n
, sizeof n
));
10783 i
= putpkt (rs
->buf
);
10785 return TARGET_XFER_E_IO
;
10788 packet_len
= getpkt_sane (&rs
->buf
, 0);
10789 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10790 return TARGET_XFER_E_IO
;
10792 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10793 error (_("Unknown remote qXfer reply: %s"), rs
->buf
.data ());
10795 /* 'm' means there is (or at least might be) more data after this
10796 batch. That does not make sense unless there's at least one byte
10797 of data in this reply. */
10798 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10799 error (_("Remote qXfer reply contained no data."));
10801 /* Got some data. */
10802 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
.data () + 1,
10803 packet_len
- 1, readbuf
, n
);
10805 /* 'l' is an EOF marker, possibly including a final block of data,
10806 or possibly empty. If we have the final block of a non-empty
10807 object, record this fact to bypass a subsequent partial read. */
10808 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10810 rs
->finished_object
= xstrdup (object_name
);
10811 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10812 rs
->finished_offset
= offset
+ i
;
10816 return TARGET_XFER_EOF
;
10820 return TARGET_XFER_OK
;
10824 enum target_xfer_status
10825 remote_target::xfer_partial (enum target_object object
,
10826 const char *annex
, gdb_byte
*readbuf
,
10827 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10828 ULONGEST
*xfered_len
)
10830 struct remote_state
*rs
;
10834 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10836 set_remote_traceframe ();
10837 set_general_thread (inferior_ptid
);
10839 rs
= get_remote_state ();
10841 /* Handle memory using the standard memory routines. */
10842 if (object
== TARGET_OBJECT_MEMORY
)
10844 /* If the remote target is connected but not running, we should
10845 pass this request down to a lower stratum (e.g. the executable
10847 if (!target_has_execution
)
10848 return TARGET_XFER_EOF
;
10850 if (writebuf
!= NULL
)
10851 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10854 return remote_read_bytes (offset
, readbuf
, len
, unit_size
,
10858 /* Handle SPU memory using qxfer packets. */
10859 if (object
== TARGET_OBJECT_SPU
)
10862 return remote_read_qxfer ("spu", annex
, readbuf
, offset
, len
,
10863 xfered_len
, &remote_protocol_packets
10864 [PACKET_qXfer_spu_read
]);
10866 return remote_write_qxfer ("spu", annex
, writebuf
, offset
, len
,
10867 xfered_len
, &remote_protocol_packets
10868 [PACKET_qXfer_spu_write
]);
10871 /* Handle extra signal info using qxfer packets. */
10872 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10875 return remote_read_qxfer ("siginfo", annex
, readbuf
, offset
, len
,
10876 xfered_len
, &remote_protocol_packets
10877 [PACKET_qXfer_siginfo_read
]);
10879 return remote_write_qxfer ("siginfo", annex
,
10880 writebuf
, offset
, len
, xfered_len
,
10881 &remote_protocol_packets
10882 [PACKET_qXfer_siginfo_write
]);
10885 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10888 return remote_read_qxfer ("statictrace", annex
,
10889 readbuf
, offset
, len
, xfered_len
,
10890 &remote_protocol_packets
10891 [PACKET_qXfer_statictrace_read
]);
10893 return TARGET_XFER_E_IO
;
10896 /* Only handle flash writes. */
10897 if (writebuf
!= NULL
)
10901 case TARGET_OBJECT_FLASH
:
10902 return remote_flash_write (offset
, len
, xfered_len
,
10906 return TARGET_XFER_E_IO
;
10910 /* Map pre-existing objects onto letters. DO NOT do this for new
10911 objects!!! Instead specify new query packets. */
10914 case TARGET_OBJECT_AVR
:
10918 case TARGET_OBJECT_AUXV
:
10919 gdb_assert (annex
== NULL
);
10920 return remote_read_qxfer ("auxv", annex
, readbuf
, offset
, len
,
10922 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10924 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10925 return remote_read_qxfer
10926 ("features", annex
, readbuf
, offset
, len
, xfered_len
,
10927 &remote_protocol_packets
[PACKET_qXfer_features
]);
10929 case TARGET_OBJECT_LIBRARIES
:
10930 return remote_read_qxfer
10931 ("libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10932 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10934 case TARGET_OBJECT_LIBRARIES_SVR4
:
10935 return remote_read_qxfer
10936 ("libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10937 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10939 case TARGET_OBJECT_MEMORY_MAP
:
10940 gdb_assert (annex
== NULL
);
10941 return remote_read_qxfer ("memory-map", annex
, readbuf
, offset
, len
,
10943 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10945 case TARGET_OBJECT_OSDATA
:
10946 /* Should only get here if we're connected. */
10947 gdb_assert (rs
->remote_desc
);
10948 return remote_read_qxfer
10949 ("osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10950 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10952 case TARGET_OBJECT_THREADS
:
10953 gdb_assert (annex
== NULL
);
10954 return remote_read_qxfer ("threads", annex
, readbuf
, offset
, len
,
10956 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10958 case TARGET_OBJECT_TRACEFRAME_INFO
:
10959 gdb_assert (annex
== NULL
);
10960 return remote_read_qxfer
10961 ("traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10962 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10964 case TARGET_OBJECT_FDPIC
:
10965 return remote_read_qxfer ("fdpic", annex
, readbuf
, offset
, len
,
10967 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10969 case TARGET_OBJECT_OPENVMS_UIB
:
10970 return remote_read_qxfer ("uib", annex
, readbuf
, offset
, len
,
10972 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10974 case TARGET_OBJECT_BTRACE
:
10975 return remote_read_qxfer ("btrace", annex
, readbuf
, offset
, len
,
10977 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10979 case TARGET_OBJECT_BTRACE_CONF
:
10980 return remote_read_qxfer ("btrace-conf", annex
, readbuf
, offset
,
10982 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10984 case TARGET_OBJECT_EXEC_FILE
:
10985 return remote_read_qxfer ("exec-file", annex
, readbuf
, offset
,
10987 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10990 return TARGET_XFER_E_IO
;
10993 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10994 large enough let the caller deal with it. */
10995 if (len
< get_remote_packet_size ())
10996 return TARGET_XFER_E_IO
;
10997 len
= get_remote_packet_size ();
10999 /* Except for querying the minimum buffer size, target must be open. */
11000 if (!rs
->remote_desc
)
11001 error (_("remote query is only available after target open"));
11003 gdb_assert (annex
!= NULL
);
11004 gdb_assert (readbuf
!= NULL
);
11006 p2
= rs
->buf
.data ();
11008 *p2
++ = query_type
;
11010 /* We used one buffer char for the remote protocol q command and
11011 another for the query type. As the remote protocol encapsulation
11012 uses 4 chars plus one extra in case we are debugging
11013 (remote_debug), we have PBUFZIZ - 7 left to pack the query
11016 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
11018 /* Bad caller may have sent forbidden characters. */
11019 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
11024 gdb_assert (annex
[i
] == '\0');
11026 i
= putpkt (rs
->buf
);
11028 return TARGET_XFER_E_IO
;
11030 getpkt (&rs
->buf
, 0);
11031 strcpy ((char *) readbuf
, rs
->buf
.data ());
11033 *xfered_len
= strlen ((char *) readbuf
);
11034 return (*xfered_len
!= 0) ? TARGET_XFER_OK
: TARGET_XFER_EOF
;
11037 /* Implementation of to_get_memory_xfer_limit. */
11040 remote_target::get_memory_xfer_limit ()
11042 return get_memory_write_packet_size ();
11046 remote_target::search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
11047 const gdb_byte
*pattern
, ULONGEST pattern_len
,
11048 CORE_ADDR
*found_addrp
)
11050 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
11051 struct remote_state
*rs
= get_remote_state ();
11052 int max_size
= get_memory_write_packet_size ();
11053 struct packet_config
*packet
=
11054 &remote_protocol_packets
[PACKET_qSearch_memory
];
11055 /* Number of packet bytes used to encode the pattern;
11056 this could be more than PATTERN_LEN due to escape characters. */
11057 int escaped_pattern_len
;
11058 /* Amount of pattern that was encodable in the packet. */
11059 int used_pattern_len
;
11062 ULONGEST found_addr
;
11064 /* Don't go to the target if we don't have to. This is done before
11065 checking packet_config_support to avoid the possibility that a
11066 success for this edge case means the facility works in
11068 if (pattern_len
> search_space_len
)
11070 if (pattern_len
== 0)
11072 *found_addrp
= start_addr
;
11076 /* If we already know the packet isn't supported, fall back to the simple
11077 way of searching memory. */
11079 if (packet_config_support (packet
) == PACKET_DISABLE
)
11081 /* Target doesn't provided special support, fall back and use the
11082 standard support (copy memory and do the search here). */
11083 return simple_search_memory (this, start_addr
, search_space_len
,
11084 pattern
, pattern_len
, found_addrp
);
11087 /* Make sure the remote is pointing at the right process. */
11088 set_general_process ();
11090 /* Insert header. */
11091 i
= snprintf (rs
->buf
.data (), max_size
,
11092 "qSearch:memory:%s;%s;",
11093 phex_nz (start_addr
, addr_size
),
11094 phex_nz (search_space_len
, sizeof (search_space_len
)));
11095 max_size
-= (i
+ 1);
11097 /* Escape as much data as fits into rs->buf. */
11098 escaped_pattern_len
=
11099 remote_escape_output (pattern
, pattern_len
, 1,
11100 (gdb_byte
*) rs
->buf
.data () + i
,
11101 &used_pattern_len
, max_size
);
11103 /* Bail if the pattern is too large. */
11104 if (used_pattern_len
!= pattern_len
)
11105 error (_("Pattern is too large to transmit to remote target."));
11107 if (putpkt_binary (rs
->buf
.data (), i
+ escaped_pattern_len
) < 0
11108 || getpkt_sane (&rs
->buf
, 0) < 0
11109 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
11111 /* The request may not have worked because the command is not
11112 supported. If so, fall back to the simple way. */
11113 if (packet_config_support (packet
) == PACKET_DISABLE
)
11115 return simple_search_memory (this, start_addr
, search_space_len
,
11116 pattern
, pattern_len
, found_addrp
);
11121 if (rs
->buf
[0] == '0')
11123 else if (rs
->buf
[0] == '1')
11126 if (rs
->buf
[1] != ',')
11127 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11128 unpack_varlen_hex (&rs
->buf
[2], &found_addr
);
11129 *found_addrp
= found_addr
;
11132 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
.data ());
11138 remote_target::rcmd (const char *command
, struct ui_file
*outbuf
)
11140 struct remote_state
*rs
= get_remote_state ();
11141 char *p
= rs
->buf
.data ();
11143 if (!rs
->remote_desc
)
11144 error (_("remote rcmd is only available after target open"));
11146 /* Send a NULL command across as an empty command. */
11147 if (command
== NULL
)
11150 /* The query prefix. */
11151 strcpy (rs
->buf
.data (), "qRcmd,");
11152 p
= strchr (rs
->buf
.data (), '\0');
11154 if ((strlen (rs
->buf
.data ()) + strlen (command
) * 2 + 8/*misc*/)
11155 > get_remote_packet_size ())
11156 error (_("\"monitor\" command ``%s'' is too long."), command
);
11158 /* Encode the actual command. */
11159 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
11161 if (putpkt (rs
->buf
) < 0)
11162 error (_("Communication problem with target."));
11164 /* get/display the response */
11169 /* XXX - see also remote_get_noisy_reply(). */
11170 QUIT
; /* Allow user to bail out with ^C. */
11172 if (getpkt_sane (&rs
->buf
, 0) == -1)
11174 /* Timeout. Continue to (try to) read responses.
11175 This is better than stopping with an error, assuming the stub
11176 is still executing the (long) monitor command.
11177 If needed, the user can interrupt gdb using C-c, obtaining
11178 an effect similar to stop on timeout. */
11181 buf
= rs
->buf
.data ();
11182 if (buf
[0] == '\0')
11183 error (_("Target does not support this command."));
11184 if (buf
[0] == 'O' && buf
[1] != 'K')
11186 remote_console_output (buf
+ 1); /* 'O' message from stub. */
11189 if (strcmp (buf
, "OK") == 0)
11191 if (strlen (buf
) == 3 && buf
[0] == 'E'
11192 && isdigit (buf
[1]) && isdigit (buf
[2]))
11194 error (_("Protocol error with Rcmd"));
11196 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
11198 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
11200 fputc_unfiltered (c
, outbuf
);
11206 std::vector
<mem_region
>
11207 remote_target::memory_map ()
11209 std::vector
<mem_region
> result
;
11210 gdb::optional
<gdb::char_vector
> text
11211 = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP
, NULL
);
11214 result
= parse_memory_map (text
->data ());
11220 packet_command (const char *args
, int from_tty
)
11222 remote_target
*remote
= get_current_remote_target ();
11224 if (remote
== nullptr)
11225 error (_("command can only be used with remote target"));
11227 remote
->packet_command (args
, from_tty
);
11231 remote_target::packet_command (const char *args
, int from_tty
)
11234 error (_("remote-packet command requires packet text as argument"));
11236 puts_filtered ("sending: ");
11237 print_packet (args
);
11238 puts_filtered ("\n");
11241 remote_state
*rs
= get_remote_state ();
11243 getpkt (&rs
->buf
, 0);
11244 puts_filtered ("received: ");
11245 print_packet (rs
->buf
.data ());
11246 puts_filtered ("\n");
11250 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11252 static void display_thread_info (struct gdb_ext_thread_info
*info
);
11254 static void threadset_test_cmd (char *cmd
, int tty
);
11256 static void threadalive_test (char *cmd
, int tty
);
11258 static void threadlist_test_cmd (char *cmd
, int tty
);
11260 int get_and_display_threadinfo (threadref
*ref
);
11262 static void threadinfo_test_cmd (char *cmd
, int tty
);
11264 static int thread_display_step (threadref
*ref
, void *context
);
11266 static void threadlist_update_test_cmd (char *cmd
, int tty
);
11268 static void init_remote_threadtests (void);
11270 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
11273 threadset_test_cmd (const char *cmd
, int tty
)
11275 int sample_thread
= SAMPLE_THREAD
;
11277 printf_filtered (_("Remote threadset test\n"));
11278 set_general_thread (sample_thread
);
11283 threadalive_test (const char *cmd
, int tty
)
11285 int sample_thread
= SAMPLE_THREAD
;
11286 int pid
= inferior_ptid
.pid ();
11287 ptid_t ptid
= ptid_t (pid
, sample_thread
, 0);
11289 if (remote_thread_alive (ptid
))
11290 printf_filtered ("PASS: Thread alive test\n");
11292 printf_filtered ("FAIL: Thread alive test\n");
11295 void output_threadid (char *title
, threadref
*ref
);
11298 output_threadid (char *title
, threadref
*ref
)
11302 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
11304 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
11308 threadlist_test_cmd (const char *cmd
, int tty
)
11311 threadref nextthread
;
11312 int done
, result_count
;
11313 threadref threadlist
[3];
11315 printf_filtered ("Remote Threadlist test\n");
11316 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
11317 &result_count
, &threadlist
[0]))
11318 printf_filtered ("FAIL: threadlist test\n");
11321 threadref
*scan
= threadlist
;
11322 threadref
*limit
= scan
+ result_count
;
11324 while (scan
< limit
)
11325 output_threadid (" thread ", scan
++);
11330 display_thread_info (struct gdb_ext_thread_info
*info
)
11332 output_threadid ("Threadid: ", &info
->threadid
);
11333 printf_filtered ("Name: %s\n ", info
->shortname
);
11334 printf_filtered ("State: %s\n", info
->display
);
11335 printf_filtered ("other: %s\n\n", info
->more_display
);
11339 get_and_display_threadinfo (threadref
*ref
)
11343 struct gdb_ext_thread_info threadinfo
;
11345 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
11346 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
11347 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
11348 display_thread_info (&threadinfo
);
11353 threadinfo_test_cmd (const char *cmd
, int tty
)
11355 int athread
= SAMPLE_THREAD
;
11359 int_to_threadref (&thread
, athread
);
11360 printf_filtered ("Remote Threadinfo test\n");
11361 if (!get_and_display_threadinfo (&thread
))
11362 printf_filtered ("FAIL cannot get thread info\n");
11366 thread_display_step (threadref
*ref
, void *context
)
11368 /* output_threadid(" threadstep ",ref); *//* simple test */
11369 return get_and_display_threadinfo (ref
);
11373 threadlist_update_test_cmd (const char *cmd
, int tty
)
11375 printf_filtered ("Remote Threadlist update test\n");
11376 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
11380 init_remote_threadtests (void)
11382 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11383 _("Fetch and print the remote list of "
11384 "thread identifiers, one pkt only"));
11385 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11386 _("Fetch and display info about one thread"));
11387 add_com ("tset", class_obscure
, threadset_test_cmd
,
11388 _("Test setting to a different thread"));
11389 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11390 _("Iterate through updating all remote thread info"));
11391 add_com ("talive", class_obscure
, threadalive_test
,
11392 _(" Remote thread alive test "));
11397 /* Convert a thread ID to a string. */
11400 remote_target::pid_to_str (ptid_t ptid
)
11402 struct remote_state
*rs
= get_remote_state ();
11404 if (ptid
== null_ptid
)
11405 return normal_pid_to_str (ptid
);
11406 else if (ptid
.is_pid ())
11408 /* Printing an inferior target id. */
11410 /* When multi-process extensions are off, there's no way in the
11411 remote protocol to know the remote process id, if there's any
11412 at all. There's one exception --- when we're connected with
11413 target extended-remote, and we manually attached to a process
11414 with "attach PID". We don't record anywhere a flag that
11415 allows us to distinguish that case from the case of
11416 connecting with extended-remote and the stub already being
11417 attached to a process, and reporting yes to qAttached, hence
11418 no smart special casing here. */
11419 if (!remote_multi_process_p (rs
))
11420 return "Remote target";
11422 return normal_pid_to_str (ptid
);
11426 if (magic_null_ptid
== ptid
)
11427 return "Thread <main>";
11428 else if (remote_multi_process_p (rs
))
11429 if (ptid
.lwp () == 0)
11430 return normal_pid_to_str (ptid
);
11432 return string_printf ("Thread %d.%ld",
11433 ptid
.pid (), ptid
.lwp ());
11435 return string_printf ("Thread %ld", ptid
.lwp ());
11439 /* Get the address of the thread local variable in OBJFILE which is
11440 stored at OFFSET within the thread local storage for thread PTID. */
11443 remote_target::get_thread_local_address (ptid_t ptid
, CORE_ADDR lm
,
11446 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11448 struct remote_state
*rs
= get_remote_state ();
11449 char *p
= rs
->buf
.data ();
11450 char *endp
= p
+ get_remote_packet_size ();
11451 enum packet_result result
;
11453 strcpy (p
, "qGetTLSAddr:");
11455 p
= write_ptid (p
, endp
, ptid
);
11457 p
+= hexnumstr (p
, offset
);
11459 p
+= hexnumstr (p
, lm
);
11463 getpkt (&rs
->buf
, 0);
11464 result
= packet_ok (rs
->buf
,
11465 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11466 if (result
== PACKET_OK
)
11470 unpack_varlen_hex (rs
->buf
.data (), &addr
);
11473 else if (result
== PACKET_UNKNOWN
)
11474 throw_error (TLS_GENERIC_ERROR
,
11475 _("Remote target doesn't support qGetTLSAddr packet"));
11477 throw_error (TLS_GENERIC_ERROR
,
11478 _("Remote target failed to process qGetTLSAddr request"));
11481 throw_error (TLS_GENERIC_ERROR
,
11482 _("TLS not supported or disabled on this target"));
11487 /* Provide thread local base, i.e. Thread Information Block address.
11488 Returns 1 if ptid is found and thread_local_base is non zero. */
11491 remote_target::get_tib_address (ptid_t ptid
, CORE_ADDR
*addr
)
11493 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11495 struct remote_state
*rs
= get_remote_state ();
11496 char *p
= rs
->buf
.data ();
11497 char *endp
= p
+ get_remote_packet_size ();
11498 enum packet_result result
;
11500 strcpy (p
, "qGetTIBAddr:");
11502 p
= write_ptid (p
, endp
, ptid
);
11506 getpkt (&rs
->buf
, 0);
11507 result
= packet_ok (rs
->buf
,
11508 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11509 if (result
== PACKET_OK
)
11512 unpack_varlen_hex (rs
->buf
.data (), &val
);
11514 *addr
= (CORE_ADDR
) val
;
11517 else if (result
== PACKET_UNKNOWN
)
11518 error (_("Remote target doesn't support qGetTIBAddr packet"));
11520 error (_("Remote target failed to process qGetTIBAddr request"));
11523 error (_("qGetTIBAddr not supported or disabled on this target"));
11528 /* Support for inferring a target description based on the current
11529 architecture and the size of a 'g' packet. While the 'g' packet
11530 can have any size (since optional registers can be left off the
11531 end), some sizes are easily recognizable given knowledge of the
11532 approximate architecture. */
11534 struct remote_g_packet_guess
11536 remote_g_packet_guess (int bytes_
, const struct target_desc
*tdesc_
)
11543 const struct target_desc
*tdesc
;
11546 struct remote_g_packet_data
: public allocate_on_obstack
11548 std::vector
<remote_g_packet_guess
> guesses
;
11551 static struct gdbarch_data
*remote_g_packet_data_handle
;
11554 remote_g_packet_data_init (struct obstack
*obstack
)
11556 return new (obstack
) remote_g_packet_data
;
11560 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11561 const struct target_desc
*tdesc
)
11563 struct remote_g_packet_data
*data
11564 = ((struct remote_g_packet_data
*)
11565 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11567 gdb_assert (tdesc
!= NULL
);
11569 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11570 if (guess
.bytes
== bytes
)
11571 internal_error (__FILE__
, __LINE__
,
11572 _("Duplicate g packet description added for size %d"),
11575 data
->guesses
.emplace_back (bytes
, tdesc
);
11578 /* Return true if remote_read_description would do anything on this target
11579 and architecture, false otherwise. */
11582 remote_read_description_p (struct target_ops
*target
)
11584 struct remote_g_packet_data
*data
11585 = ((struct remote_g_packet_data
*)
11586 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11588 return !data
->guesses
.empty ();
11591 const struct target_desc
*
11592 remote_target::read_description ()
11594 struct remote_g_packet_data
*data
11595 = ((struct remote_g_packet_data
*)
11596 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11598 /* Do not try this during initial connection, when we do not know
11599 whether there is a running but stopped thread. */
11600 if (!target_has_execution
|| inferior_ptid
== null_ptid
)
11601 return beneath ()->read_description ();
11603 if (!data
->guesses
.empty ())
11605 int bytes
= send_g_packet ();
11607 for (const remote_g_packet_guess
&guess
: data
->guesses
)
11608 if (guess
.bytes
== bytes
)
11609 return guess
.tdesc
;
11611 /* We discard the g packet. A minor optimization would be to
11612 hold on to it, and fill the register cache once we have selected
11613 an architecture, but it's too tricky to do safely. */
11616 return beneath ()->read_description ();
11619 /* Remote file transfer support. This is host-initiated I/O, not
11620 target-initiated; for target-initiated, see remote-fileio.c. */
11622 /* If *LEFT is at least the length of STRING, copy STRING to
11623 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11624 decrease *LEFT. Otherwise raise an error. */
11627 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11629 int len
= strlen (string
);
11632 error (_("Packet too long for target."));
11634 memcpy (*buffer
, string
, len
);
11638 /* NUL-terminate the buffer as a convenience, if there is
11644 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11645 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11646 decrease *LEFT. Otherwise raise an error. */
11649 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11652 if (2 * len
> *left
)
11653 error (_("Packet too long for target."));
11655 bin2hex (bytes
, *buffer
, len
);
11656 *buffer
+= 2 * len
;
11659 /* NUL-terminate the buffer as a convenience, if there is
11665 /* If *LEFT is large enough, convert VALUE to hex and add it to
11666 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11667 decrease *LEFT. Otherwise raise an error. */
11670 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11672 int len
= hexnumlen (value
);
11675 error (_("Packet too long for target."));
11677 hexnumstr (*buffer
, value
);
11681 /* NUL-terminate the buffer as a convenience, if there is
11687 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11688 value, *REMOTE_ERRNO to the remote error number or zero if none
11689 was included, and *ATTACHMENT to point to the start of the annex
11690 if any. The length of the packet isn't needed here; there may
11691 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11693 Return 0 if the packet could be parsed, -1 if it could not. If
11694 -1 is returned, the other variables may not be initialized. */
11697 remote_hostio_parse_result (char *buffer
, int *retcode
,
11698 int *remote_errno
, char **attachment
)
11703 *attachment
= NULL
;
11705 if (buffer
[0] != 'F')
11709 *retcode
= strtol (&buffer
[1], &p
, 16);
11710 if (errno
!= 0 || p
== &buffer
[1])
11713 /* Check for ",errno". */
11717 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11718 if (errno
!= 0 || p
+ 1 == p2
)
11723 /* Check for ";attachment". If there is no attachment, the
11724 packet should end here. */
11727 *attachment
= p
+ 1;
11730 else if (*p
== '\0')
11736 /* Send a prepared I/O packet to the target and read its response.
11737 The prepared packet is in the global RS->BUF before this function
11738 is called, and the answer is there when we return.
11740 COMMAND_BYTES is the length of the request to send, which may include
11741 binary data. WHICH_PACKET is the packet configuration to check
11742 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11743 is set to the error number and -1 is returned. Otherwise the value
11744 returned by the function is returned.
11746 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11747 attachment is expected; an error will be reported if there's a
11748 mismatch. If one is found, *ATTACHMENT will be set to point into
11749 the packet buffer and *ATTACHMENT_LEN will be set to the
11750 attachment's length. */
11753 remote_target::remote_hostio_send_command (int command_bytes
, int which_packet
,
11754 int *remote_errno
, char **attachment
,
11755 int *attachment_len
)
11757 struct remote_state
*rs
= get_remote_state ();
11758 int ret
, bytes_read
;
11759 char *attachment_tmp
;
11761 if (packet_support (which_packet
) == PACKET_DISABLE
)
11763 *remote_errno
= FILEIO_ENOSYS
;
11767 putpkt_binary (rs
->buf
.data (), command_bytes
);
11768 bytes_read
= getpkt_sane (&rs
->buf
, 0);
11770 /* If it timed out, something is wrong. Don't try to parse the
11772 if (bytes_read
< 0)
11774 *remote_errno
= FILEIO_EINVAL
;
11778 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11781 *remote_errno
= FILEIO_EINVAL
;
11783 case PACKET_UNKNOWN
:
11784 *remote_errno
= FILEIO_ENOSYS
;
11790 if (remote_hostio_parse_result (rs
->buf
.data (), &ret
, remote_errno
,
11793 *remote_errno
= FILEIO_EINVAL
;
11797 /* Make sure we saw an attachment if and only if we expected one. */
11798 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11799 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11801 *remote_errno
= FILEIO_EINVAL
;
11805 /* If an attachment was found, it must point into the packet buffer;
11806 work out how many bytes there were. */
11807 if (attachment_tmp
!= NULL
)
11809 *attachment
= attachment_tmp
;
11810 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
.data ());
11816 /* See declaration.h. */
11819 readahead_cache::invalidate ()
11824 /* See declaration.h. */
11827 readahead_cache::invalidate_fd (int fd
)
11829 if (this->fd
== fd
)
11833 /* Set the filesystem remote_hostio functions that take FILENAME
11834 arguments will use. Return 0 on success, or -1 if an error
11835 occurs (and set *REMOTE_ERRNO). */
11838 remote_target::remote_hostio_set_filesystem (struct inferior
*inf
,
11841 struct remote_state
*rs
= get_remote_state ();
11842 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11843 char *p
= rs
->buf
.data ();
11844 int left
= get_remote_packet_size () - 1;
11848 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11851 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11854 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11856 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11857 remote_buffer_add_string (&p
, &left
, arg
);
11859 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_setfs
,
11860 remote_errno
, NULL
, NULL
);
11862 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11866 rs
->fs_pid
= required_pid
;
11871 /* Implementation of to_fileio_open. */
11874 remote_target::remote_hostio_open (inferior
*inf
, const char *filename
,
11875 int flags
, int mode
, int warn_if_slow
,
11878 struct remote_state
*rs
= get_remote_state ();
11879 char *p
= rs
->buf
.data ();
11880 int left
= get_remote_packet_size () - 1;
11884 static int warning_issued
= 0;
11886 printf_unfiltered (_("Reading %s from remote target...\n"),
11889 if (!warning_issued
)
11891 warning (_("File transfers from remote targets can be slow."
11892 " Use \"set sysroot\" to access files locally"
11894 warning_issued
= 1;
11898 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11901 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11903 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11904 strlen (filename
));
11905 remote_buffer_add_string (&p
, &left
, ",");
11907 remote_buffer_add_int (&p
, &left
, flags
);
11908 remote_buffer_add_string (&p
, &left
, ",");
11910 remote_buffer_add_int (&p
, &left
, mode
);
11912 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_open
,
11913 remote_errno
, NULL
, NULL
);
11917 remote_target::fileio_open (struct inferior
*inf
, const char *filename
,
11918 int flags
, int mode
, int warn_if_slow
,
11921 return remote_hostio_open (inf
, filename
, flags
, mode
, warn_if_slow
,
11925 /* Implementation of to_fileio_pwrite. */
11928 remote_target::remote_hostio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11929 ULONGEST offset
, int *remote_errno
)
11931 struct remote_state
*rs
= get_remote_state ();
11932 char *p
= rs
->buf
.data ();
11933 int left
= get_remote_packet_size ();
11936 rs
->readahead_cache
.invalidate_fd (fd
);
11938 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11940 remote_buffer_add_int (&p
, &left
, fd
);
11941 remote_buffer_add_string (&p
, &left
, ",");
11943 remote_buffer_add_int (&p
, &left
, offset
);
11944 remote_buffer_add_string (&p
, &left
, ",");
11946 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11947 (get_remote_packet_size ()
11948 - (p
- rs
->buf
.data ())));
11950 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pwrite
,
11951 remote_errno
, NULL
, NULL
);
11955 remote_target::fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
11956 ULONGEST offset
, int *remote_errno
)
11958 return remote_hostio_pwrite (fd
, write_buf
, len
, offset
, remote_errno
);
11961 /* Helper for the implementation of to_fileio_pread. Read the file
11962 from the remote side with vFile:pread. */
11965 remote_target::remote_hostio_pread_vFile (int fd
, gdb_byte
*read_buf
, int len
,
11966 ULONGEST offset
, int *remote_errno
)
11968 struct remote_state
*rs
= get_remote_state ();
11969 char *p
= rs
->buf
.data ();
11971 int left
= get_remote_packet_size ();
11972 int ret
, attachment_len
;
11975 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11977 remote_buffer_add_int (&p
, &left
, fd
);
11978 remote_buffer_add_string (&p
, &left
, ",");
11980 remote_buffer_add_int (&p
, &left
, len
);
11981 remote_buffer_add_string (&p
, &left
, ",");
11983 remote_buffer_add_int (&p
, &left
, offset
);
11985 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_pread
,
11986 remote_errno
, &attachment
,
11992 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11994 if (read_len
!= ret
)
11995 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
12000 /* See declaration.h. */
12003 readahead_cache::pread (int fd
, gdb_byte
*read_buf
, size_t len
,
12007 && this->offset
<= offset
12008 && offset
< this->offset
+ this->bufsize
)
12010 ULONGEST max
= this->offset
+ this->bufsize
;
12012 if (offset
+ len
> max
)
12013 len
= max
- offset
;
12015 memcpy (read_buf
, this->buf
+ offset
- this->offset
, len
);
12022 /* Implementation of to_fileio_pread. */
12025 remote_target::remote_hostio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12026 ULONGEST offset
, int *remote_errno
)
12029 struct remote_state
*rs
= get_remote_state ();
12030 readahead_cache
*cache
= &rs
->readahead_cache
;
12032 ret
= cache
->pread (fd
, read_buf
, len
, offset
);
12035 cache
->hit_count
++;
12038 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
12039 pulongest (cache
->hit_count
));
12043 cache
->miss_count
++;
12045 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
12046 pulongest (cache
->miss_count
));
12049 cache
->offset
= offset
;
12050 cache
->bufsize
= get_remote_packet_size ();
12051 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
12053 ret
= remote_hostio_pread_vFile (cache
->fd
, cache
->buf
, cache
->bufsize
,
12054 cache
->offset
, remote_errno
);
12057 cache
->invalidate_fd (fd
);
12061 cache
->bufsize
= ret
;
12062 return cache
->pread (fd
, read_buf
, len
, offset
);
12066 remote_target::fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
12067 ULONGEST offset
, int *remote_errno
)
12069 return remote_hostio_pread (fd
, read_buf
, len
, offset
, remote_errno
);
12072 /* Implementation of to_fileio_close. */
12075 remote_target::remote_hostio_close (int fd
, int *remote_errno
)
12077 struct remote_state
*rs
= get_remote_state ();
12078 char *p
= rs
->buf
.data ();
12079 int left
= get_remote_packet_size () - 1;
12081 rs
->readahead_cache
.invalidate_fd (fd
);
12083 remote_buffer_add_string (&p
, &left
, "vFile:close:");
12085 remote_buffer_add_int (&p
, &left
, fd
);
12087 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_close
,
12088 remote_errno
, NULL
, NULL
);
12092 remote_target::fileio_close (int fd
, int *remote_errno
)
12094 return remote_hostio_close (fd
, remote_errno
);
12097 /* Implementation of to_fileio_unlink. */
12100 remote_target::remote_hostio_unlink (inferior
*inf
, const char *filename
,
12103 struct remote_state
*rs
= get_remote_state ();
12104 char *p
= rs
->buf
.data ();
12105 int left
= get_remote_packet_size () - 1;
12107 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12110 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
12112 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12113 strlen (filename
));
12115 return remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_unlink
,
12116 remote_errno
, NULL
, NULL
);
12120 remote_target::fileio_unlink (struct inferior
*inf
, const char *filename
,
12123 return remote_hostio_unlink (inf
, filename
, remote_errno
);
12126 /* Implementation of to_fileio_readlink. */
12128 gdb::optional
<std::string
>
12129 remote_target::fileio_readlink (struct inferior
*inf
, const char *filename
,
12132 struct remote_state
*rs
= get_remote_state ();
12133 char *p
= rs
->buf
.data ();
12135 int left
= get_remote_packet_size ();
12136 int len
, attachment_len
;
12139 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
12142 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
12144 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
12145 strlen (filename
));
12147 len
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_readlink
,
12148 remote_errno
, &attachment
,
12154 std::string
ret (len
, '\0');
12156 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12157 (gdb_byte
*) &ret
[0], len
);
12158 if (read_len
!= len
)
12159 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
12164 /* Implementation of to_fileio_fstat. */
12167 remote_target::fileio_fstat (int fd
, struct stat
*st
, int *remote_errno
)
12169 struct remote_state
*rs
= get_remote_state ();
12170 char *p
= rs
->buf
.data ();
12171 int left
= get_remote_packet_size ();
12172 int attachment_len
, ret
;
12174 struct fio_stat fst
;
12177 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
12179 remote_buffer_add_int (&p
, &left
, fd
);
12181 ret
= remote_hostio_send_command (p
- rs
->buf
.data (), PACKET_vFile_fstat
,
12182 remote_errno
, &attachment
,
12186 if (*remote_errno
!= FILEIO_ENOSYS
)
12189 /* Strictly we should return -1, ENOSYS here, but when
12190 "set sysroot remote:" was implemented in August 2008
12191 BFD's need for a stat function was sidestepped with
12192 this hack. This was not remedied until March 2015
12193 so we retain the previous behavior to avoid breaking
12196 Note that the memset is a March 2015 addition; older
12197 GDBs set st_size *and nothing else* so the structure
12198 would have garbage in all other fields. This might
12199 break something but retaining the previous behavior
12200 here would be just too wrong. */
12202 memset (st
, 0, sizeof (struct stat
));
12203 st
->st_size
= INT_MAX
;
12207 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
12208 (gdb_byte
*) &fst
, sizeof (fst
));
12210 if (read_len
!= ret
)
12211 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
12213 if (read_len
!= sizeof (fst
))
12214 error (_("vFile:fstat returned %d bytes, but expecting %d."),
12215 read_len
, (int) sizeof (fst
));
12217 remote_fileio_to_host_stat (&fst
, st
);
12222 /* Implementation of to_filesystem_is_local. */
12225 remote_target::filesystem_is_local ()
12227 /* Valgrind GDB presents itself as a remote target but works
12228 on the local filesystem: it does not implement remote get
12229 and users are not expected to set a sysroot. To handle
12230 this case we treat the remote filesystem as local if the
12231 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12232 does not support vFile:open. */
12233 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
12235 enum packet_support ps
= packet_support (PACKET_vFile_open
);
12237 if (ps
== PACKET_SUPPORT_UNKNOWN
)
12239 int fd
, remote_errno
;
12241 /* Try opening a file to probe support. The supplied
12242 filename is irrelevant, we only care about whether
12243 the stub recognizes the packet or not. */
12244 fd
= remote_hostio_open (NULL
, "just probing",
12245 FILEIO_O_RDONLY
, 0700, 0,
12249 remote_hostio_close (fd
, &remote_errno
);
12251 ps
= packet_support (PACKET_vFile_open
);
12254 if (ps
== PACKET_DISABLE
)
12256 static int warning_issued
= 0;
12258 if (!warning_issued
)
12260 warning (_("remote target does not support file"
12261 " transfer, attempting to access files"
12262 " from local filesystem."));
12263 warning_issued
= 1;
12274 remote_fileio_errno_to_host (int errnum
)
12280 case FILEIO_ENOENT
:
12288 case FILEIO_EACCES
:
12290 case FILEIO_EFAULT
:
12294 case FILEIO_EEXIST
:
12296 case FILEIO_ENODEV
:
12298 case FILEIO_ENOTDIR
:
12300 case FILEIO_EISDIR
:
12302 case FILEIO_EINVAL
:
12304 case FILEIO_ENFILE
:
12306 case FILEIO_EMFILE
:
12310 case FILEIO_ENOSPC
:
12312 case FILEIO_ESPIPE
:
12316 case FILEIO_ENOSYS
:
12318 case FILEIO_ENAMETOOLONG
:
12319 return ENAMETOOLONG
;
12325 remote_hostio_error (int errnum
)
12327 int host_error
= remote_fileio_errno_to_host (errnum
);
12329 if (host_error
== -1)
12330 error (_("Unknown remote I/O error %d"), errnum
);
12332 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
12335 /* A RAII wrapper around a remote file descriptor. */
12337 class scoped_remote_fd
12340 scoped_remote_fd (remote_target
*remote
, int fd
)
12341 : m_remote (remote
), m_fd (fd
)
12345 ~scoped_remote_fd ()
12352 m_remote
->remote_hostio_close (m_fd
, &remote_errno
);
12356 /* Swallow exception before it escapes the dtor. If
12357 something goes wrong, likely the connection is gone,
12358 and there's nothing else that can be done. */
12363 DISABLE_COPY_AND_ASSIGN (scoped_remote_fd
);
12365 /* Release ownership of the file descriptor, and return it. */
12366 ATTRIBUTE_UNUSED_RESULT
int release () noexcept
12373 /* Return the owned file descriptor. */
12374 int get () const noexcept
12380 /* The remote target. */
12381 remote_target
*m_remote
;
12383 /* The owned remote I/O file descriptor. */
12388 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
12390 remote_target
*remote
= get_current_remote_target ();
12392 if (remote
== nullptr)
12393 error (_("command can only be used with remote target"));
12395 remote
->remote_file_put (local_file
, remote_file
, from_tty
);
12399 remote_target::remote_file_put (const char *local_file
, const char *remote_file
,
12402 int retcode
, remote_errno
, bytes
, io_size
;
12403 int bytes_in_buffer
;
12407 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
12409 perror_with_name (local_file
);
12411 scoped_remote_fd fd
12412 (this, remote_hostio_open (NULL
,
12413 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
12415 0700, 0, &remote_errno
));
12416 if (fd
.get () == -1)
12417 remote_hostio_error (remote_errno
);
12419 /* Send up to this many bytes at once. They won't all fit in the
12420 remote packet limit, so we'll transfer slightly fewer. */
12421 io_size
= get_remote_packet_size ();
12422 gdb::byte_vector
buffer (io_size
);
12424 bytes_in_buffer
= 0;
12427 while (bytes_in_buffer
|| !saw_eof
)
12431 bytes
= fread (buffer
.data () + bytes_in_buffer
, 1,
12432 io_size
- bytes_in_buffer
,
12436 if (ferror (file
.get ()))
12437 error (_("Error reading %s."), local_file
);
12440 /* EOF. Unless there is something still in the
12441 buffer from the last iteration, we are done. */
12443 if (bytes_in_buffer
== 0)
12451 bytes
+= bytes_in_buffer
;
12452 bytes_in_buffer
= 0;
12454 retcode
= remote_hostio_pwrite (fd
.get (), buffer
.data (), bytes
,
12455 offset
, &remote_errno
);
12458 remote_hostio_error (remote_errno
);
12459 else if (retcode
== 0)
12460 error (_("Remote write of %d bytes returned 0!"), bytes
);
12461 else if (retcode
< bytes
)
12463 /* Short write. Save the rest of the read data for the next
12465 bytes_in_buffer
= bytes
- retcode
;
12466 memmove (buffer
.data (), buffer
.data () + retcode
, bytes_in_buffer
);
12472 if (remote_hostio_close (fd
.release (), &remote_errno
))
12473 remote_hostio_error (remote_errno
);
12476 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12480 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12482 remote_target
*remote
= get_current_remote_target ();
12484 if (remote
== nullptr)
12485 error (_("command can only be used with remote target"));
12487 remote
->remote_file_get (remote_file
, local_file
, from_tty
);
12491 remote_target::remote_file_get (const char *remote_file
, const char *local_file
,
12494 int remote_errno
, bytes
, io_size
;
12497 scoped_remote_fd fd
12498 (this, remote_hostio_open (NULL
,
12499 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12501 if (fd
.get () == -1)
12502 remote_hostio_error (remote_errno
);
12504 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12506 perror_with_name (local_file
);
12508 /* Send up to this many bytes at once. They won't all fit in the
12509 remote packet limit, so we'll transfer slightly fewer. */
12510 io_size
= get_remote_packet_size ();
12511 gdb::byte_vector
buffer (io_size
);
12516 bytes
= remote_hostio_pread (fd
.get (), buffer
.data (), io_size
, offset
,
12519 /* Success, but no bytes, means end-of-file. */
12522 remote_hostio_error (remote_errno
);
12526 bytes
= fwrite (buffer
.data (), 1, bytes
, file
.get ());
12528 perror_with_name (local_file
);
12531 if (remote_hostio_close (fd
.release (), &remote_errno
))
12532 remote_hostio_error (remote_errno
);
12535 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12539 remote_file_delete (const char *remote_file
, int from_tty
)
12541 remote_target
*remote
= get_current_remote_target ();
12543 if (remote
== nullptr)
12544 error (_("command can only be used with remote target"));
12546 remote
->remote_file_delete (remote_file
, from_tty
);
12550 remote_target::remote_file_delete (const char *remote_file
, int from_tty
)
12552 int retcode
, remote_errno
;
12554 retcode
= remote_hostio_unlink (NULL
, remote_file
, &remote_errno
);
12556 remote_hostio_error (remote_errno
);
12559 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12563 remote_put_command (const char *args
, int from_tty
)
12566 error_no_arg (_("file to put"));
12568 gdb_argv
argv (args
);
12569 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12570 error (_("Invalid parameters to remote put"));
12572 remote_file_put (argv
[0], argv
[1], from_tty
);
12576 remote_get_command (const char *args
, int from_tty
)
12579 error_no_arg (_("file to get"));
12581 gdb_argv
argv (args
);
12582 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12583 error (_("Invalid parameters to remote get"));
12585 remote_file_get (argv
[0], argv
[1], from_tty
);
12589 remote_delete_command (const char *args
, int from_tty
)
12592 error_no_arg (_("file to delete"));
12594 gdb_argv
argv (args
);
12595 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12596 error (_("Invalid parameters to remote delete"));
12598 remote_file_delete (argv
[0], from_tty
);
12602 remote_command (const char *args
, int from_tty
)
12604 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12608 remote_target::can_execute_reverse ()
12610 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12611 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12618 remote_target::supports_non_stop ()
12624 remote_target::supports_disable_randomization ()
12626 /* Only supported in extended mode. */
12631 remote_target::supports_multi_process ()
12633 struct remote_state
*rs
= get_remote_state ();
12635 return remote_multi_process_p (rs
);
12639 remote_supports_cond_tracepoints ()
12641 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12645 remote_target::supports_evaluation_of_breakpoint_conditions ()
12647 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12651 remote_supports_fast_tracepoints ()
12653 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12657 remote_supports_static_tracepoints ()
12659 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12663 remote_supports_install_in_trace ()
12665 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12669 remote_target::supports_enable_disable_tracepoint ()
12671 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12676 remote_target::supports_string_tracing ()
12678 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12682 remote_target::can_run_breakpoint_commands ()
12684 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12688 remote_target::trace_init ()
12690 struct remote_state
*rs
= get_remote_state ();
12693 remote_get_noisy_reply ();
12694 if (strcmp (rs
->buf
.data (), "OK") != 0)
12695 error (_("Target does not support this command."));
12698 /* Recursive routine to walk through command list including loops, and
12699 download packets for each command. */
12702 remote_target::remote_download_command_source (int num
, ULONGEST addr
,
12703 struct command_line
*cmds
)
12705 struct remote_state
*rs
= get_remote_state ();
12706 struct command_line
*cmd
;
12708 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12710 QUIT
; /* Allow user to bail out with ^C. */
12711 strcpy (rs
->buf
.data (), "QTDPsrc:");
12712 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12713 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12714 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12716 remote_get_noisy_reply ();
12717 if (strcmp (rs
->buf
.data (), "OK"))
12718 warning (_("Target does not support source download."));
12720 if (cmd
->control_type
== while_control
12721 || cmd
->control_type
== while_stepping_control
)
12723 remote_download_command_source (num
, addr
, cmd
->body_list_0
.get ());
12725 QUIT
; /* Allow user to bail out with ^C. */
12726 strcpy (rs
->buf
.data (), "QTDPsrc:");
12727 encode_source_string (num
, addr
, "cmd", "end",
12728 rs
->buf
.data () + strlen (rs
->buf
.data ()),
12729 rs
->buf
.size () - strlen (rs
->buf
.data ()));
12731 remote_get_noisy_reply ();
12732 if (strcmp (rs
->buf
.data (), "OK"))
12733 warning (_("Target does not support source download."));
12739 remote_target::download_tracepoint (struct bp_location
*loc
)
12743 std::vector
<std::string
> tdp_actions
;
12744 std::vector
<std::string
> stepping_actions
;
12746 struct breakpoint
*b
= loc
->owner
;
12747 struct tracepoint
*t
= (struct tracepoint
*) b
;
12748 struct remote_state
*rs
= get_remote_state ();
12750 const char *err_msg
= _("Tracepoint packet too large for target.");
12753 /* We use a buffer other than rs->buf because we'll build strings
12754 across multiple statements, and other statements in between could
12756 gdb::char_vector
buf (get_remote_packet_size ());
12758 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12760 tpaddr
= loc
->address
;
12761 sprintf_vma (addrbuf
, tpaddr
);
12762 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:%x:%s:%c:%lx:%x",
12763 b
->number
, addrbuf
, /* address */
12764 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12765 t
->step_count
, t
->pass_count
);
12767 if (ret
< 0 || ret
>= buf
.size ())
12768 error ("%s", err_msg
);
12770 /* Fast tracepoints are mostly handled by the target, but we can
12771 tell the target how big of an instruction block should be moved
12773 if (b
->type
== bp_fast_tracepoint
)
12775 /* Only test for support at download time; we may not know
12776 target capabilities at definition time. */
12777 if (remote_supports_fast_tracepoints ())
12779 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12782 size_left
= buf
.size () - strlen (buf
.data ());
12783 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12785 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12787 if (ret
< 0 || ret
>= size_left
)
12788 error ("%s", err_msg
);
12791 /* If it passed validation at definition but fails now,
12792 something is very wrong. */
12793 internal_error (__FILE__
, __LINE__
,
12794 _("Fast tracepoint not "
12795 "valid during download"));
12798 /* Fast tracepoints are functionally identical to regular
12799 tracepoints, so don't take lack of support as a reason to
12800 give up on the trace run. */
12801 warning (_("Target does not support fast tracepoints, "
12802 "downloading %d as regular tracepoint"), b
->number
);
12804 else if (b
->type
== bp_static_tracepoint
)
12806 /* Only test for support at download time; we may not know
12807 target capabilities at definition time. */
12808 if (remote_supports_static_tracepoints ())
12810 struct static_tracepoint_marker marker
;
12812 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12814 size_left
= buf
.size () - strlen (buf
.data ());
12815 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12818 if (ret
< 0 || ret
>= size_left
)
12819 error ("%s", err_msg
);
12822 error (_("Static tracepoint not valid during download"));
12825 /* Fast tracepoints are functionally identical to regular
12826 tracepoints, so don't take lack of support as a reason
12827 to give up on the trace run. */
12828 error (_("Target does not support static tracepoints"));
12830 /* If the tracepoint has a conditional, make it into an agent
12831 expression and append to the definition. */
12834 /* Only test support at download time, we may not know target
12835 capabilities at definition time. */
12836 if (remote_supports_cond_tracepoints ())
12838 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
,
12841 size_left
= buf
.size () - strlen (buf
.data ());
12843 ret
= snprintf (buf
.data () + strlen (buf
.data ()),
12844 size_left
, ":X%x,", aexpr
->len
);
12846 if (ret
< 0 || ret
>= size_left
)
12847 error ("%s", err_msg
);
12849 size_left
= buf
.size () - strlen (buf
.data ());
12851 /* Two bytes to encode each aexpr byte, plus the terminating
12853 if (aexpr
->len
* 2 + 1 > size_left
)
12854 error ("%s", err_msg
);
12856 pkt
= buf
.data () + strlen (buf
.data ());
12858 for (int ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12859 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12863 warning (_("Target does not support conditional tracepoints, "
12864 "ignoring tp %d cond"), b
->number
);
12867 if (b
->commands
|| *default_collect
)
12869 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 putpkt (buf
.data ());
12879 remote_get_noisy_reply ();
12880 if (strcmp (rs
->buf
.data (), "OK"))
12881 error (_("Target does not support tracepoints."));
12883 /* do_single_steps (t); */
12884 for (auto action_it
= tdp_actions
.begin ();
12885 action_it
!= tdp_actions
.end (); action_it
++)
12887 QUIT
; /* Allow user to bail out with ^C. */
12889 bool has_more
= ((action_it
+ 1) != tdp_actions
.end ()
12890 || !stepping_actions
.empty ());
12892 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%c",
12893 b
->number
, addrbuf
, /* address */
12894 action_it
->c_str (),
12895 has_more
? '-' : 0);
12897 if (ret
< 0 || ret
>= buf
.size ())
12898 error ("%s", err_msg
);
12900 putpkt (buf
.data ());
12901 remote_get_noisy_reply ();
12902 if (strcmp (rs
->buf
.data (), "OK"))
12903 error (_("Error on target while setting tracepoints."));
12906 for (auto action_it
= stepping_actions
.begin ();
12907 action_it
!= stepping_actions
.end (); action_it
++)
12909 QUIT
; /* Allow user to bail out with ^C. */
12911 bool is_first
= action_it
== stepping_actions
.begin ();
12912 bool has_more
= (action_it
+ 1) != stepping_actions
.end ();
12914 ret
= snprintf (buf
.data (), buf
.size (), "QTDP:-%x:%s:%s%s%s",
12915 b
->number
, addrbuf
, /* address */
12916 is_first
? "S" : "",
12917 action_it
->c_str (),
12918 has_more
? "-" : "");
12920 if (ret
< 0 || ret
>= buf
.size ())
12921 error ("%s", err_msg
);
12923 putpkt (buf
.data ());
12924 remote_get_noisy_reply ();
12925 if (strcmp (rs
->buf
.data (), "OK"))
12926 error (_("Error on target while setting tracepoints."));
12929 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12931 if (b
->location
!= NULL
)
12933 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12935 if (ret
< 0 || ret
>= buf
.size ())
12936 error ("%s", err_msg
);
12938 encode_source_string (b
->number
, loc
->address
, "at",
12939 event_location_to_string (b
->location
.get ()),
12940 buf
.data () + strlen (buf
.data ()),
12941 buf
.size () - strlen (buf
.data ()));
12942 putpkt (buf
.data ());
12943 remote_get_noisy_reply ();
12944 if (strcmp (rs
->buf
.data (), "OK"))
12945 warning (_("Target does not support source download."));
12947 if (b
->cond_string
)
12949 ret
= snprintf (buf
.data (), buf
.size (), "QTDPsrc:");
12951 if (ret
< 0 || ret
>= buf
.size ())
12952 error ("%s", err_msg
);
12954 encode_source_string (b
->number
, loc
->address
,
12955 "cond", b
->cond_string
,
12956 buf
.data () + strlen (buf
.data ()),
12957 buf
.size () - strlen (buf
.data ()));
12958 putpkt (buf
.data ());
12959 remote_get_noisy_reply ();
12960 if (strcmp (rs
->buf
.data (), "OK"))
12961 warning (_("Target does not support source download."));
12963 remote_download_command_source (b
->number
, loc
->address
,
12964 breakpoint_commands (b
));
12969 remote_target::can_download_tracepoint ()
12971 struct remote_state
*rs
= get_remote_state ();
12972 struct trace_status
*ts
;
12975 /* Don't try to install tracepoints until we've relocated our
12976 symbols, and fetched and merged the target's tracepoint list with
12978 if (rs
->starting_up
)
12981 ts
= current_trace_status ();
12982 status
= get_trace_status (ts
);
12984 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12987 /* If we are in a tracing experiment, but remote stub doesn't support
12988 installing tracepoint in trace, we have to return. */
12989 if (!remote_supports_install_in_trace ())
12997 remote_target::download_trace_state_variable (const trace_state_variable
&tsv
)
12999 struct remote_state
*rs
= get_remote_state ();
13002 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13003 tsv
.number
, phex ((ULONGEST
) tsv
.initial_value
, 8),
13005 p
= rs
->buf
.data () + strlen (rs
->buf
.data ());
13006 if ((p
- rs
->buf
.data ()) + tsv
.name
.length () * 2
13007 >= get_remote_packet_size ())
13008 error (_("Trace state variable name too long for tsv definition packet"));
13009 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
.name
.data ()), p
, tsv
.name
.length ());
13012 remote_get_noisy_reply ();
13013 if (rs
->buf
[0] == '\0')
13014 error (_("Target does not support this command."));
13015 if (strcmp (rs
->buf
.data (), "OK") != 0)
13016 error (_("Error on target while downloading trace state variable."));
13020 remote_target::enable_tracepoint (struct bp_location
*location
)
13022 struct remote_state
*rs
= get_remote_state ();
13025 sprintf_vma (addr_buf
, location
->address
);
13026 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13027 location
->owner
->number
, addr_buf
);
13029 remote_get_noisy_reply ();
13030 if (rs
->buf
[0] == '\0')
13031 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13032 if (strcmp (rs
->buf
.data (), "OK") != 0)
13033 error (_("Error on target while enabling tracepoint."));
13037 remote_target::disable_tracepoint (struct bp_location
*location
)
13039 struct remote_state
*rs
= get_remote_state ();
13042 sprintf_vma (addr_buf
, location
->address
);
13043 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13044 location
->owner
->number
, addr_buf
);
13046 remote_get_noisy_reply ();
13047 if (rs
->buf
[0] == '\0')
13048 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13049 if (strcmp (rs
->buf
.data (), "OK") != 0)
13050 error (_("Error on target while disabling tracepoint."));
13054 remote_target::trace_set_readonly_regions ()
13058 bfd_size_type size
;
13064 return; /* No information to give. */
13066 struct remote_state
*rs
= get_remote_state ();
13068 strcpy (rs
->buf
.data (), "QTro");
13069 offset
= strlen (rs
->buf
.data ());
13070 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
13072 char tmp1
[40], tmp2
[40];
13075 if ((s
->flags
& SEC_LOAD
) == 0 ||
13076 /* (s->flags & SEC_CODE) == 0 || */
13077 (s
->flags
& SEC_READONLY
) == 0)
13081 vma
= bfd_get_section_vma (abfd
, s
);
13082 size
= bfd_get_section_size (s
);
13083 sprintf_vma (tmp1
, vma
);
13084 sprintf_vma (tmp2
, vma
+ size
);
13085 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
13086 if (offset
+ sec_length
+ 1 > rs
->buf
.size ())
13088 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
13090 Too many sections for read-only sections definition packet."));
13093 xsnprintf (rs
->buf
.data () + offset
, rs
->buf
.size () - offset
, ":%s,%s",
13095 offset
+= sec_length
;
13100 getpkt (&rs
->buf
, 0);
13105 remote_target::trace_start ()
13107 struct remote_state
*rs
= get_remote_state ();
13109 putpkt ("QTStart");
13110 remote_get_noisy_reply ();
13111 if (rs
->buf
[0] == '\0')
13112 error (_("Target does not support this command."));
13113 if (strcmp (rs
->buf
.data (), "OK") != 0)
13114 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13118 remote_target::get_trace_status (struct trace_status
*ts
)
13120 /* Initialize it just to avoid a GCC false warning. */
13122 /* FIXME we need to get register block size some other way. */
13123 extern int trace_regblock_size
;
13124 enum packet_result result
;
13125 struct remote_state
*rs
= get_remote_state ();
13127 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
13130 trace_regblock_size
13131 = rs
->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet
;
13133 putpkt ("qTStatus");
13137 p
= remote_get_noisy_reply ();
13139 catch (const gdb_exception_error
&ex
)
13141 if (ex
.error
!= TARGET_CLOSE_ERROR
)
13143 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
13149 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
13151 /* If the remote target doesn't do tracing, flag it. */
13152 if (result
== PACKET_UNKNOWN
)
13155 /* We're working with a live target. */
13156 ts
->filename
= NULL
;
13159 error (_("Bogus trace status reply from target: %s"), rs
->buf
.data ());
13161 /* Function 'parse_trace_status' sets default value of each field of
13162 'ts' at first, so we don't have to do it here. */
13163 parse_trace_status (p
, ts
);
13165 return ts
->running
;
13169 remote_target::get_tracepoint_status (struct breakpoint
*bp
,
13170 struct uploaded_tp
*utp
)
13172 struct remote_state
*rs
= get_remote_state ();
13174 struct bp_location
*loc
;
13175 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
13176 size_t size
= get_remote_packet_size ();
13181 tp
->traceframe_usage
= 0;
13182 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
13184 /* If the tracepoint was never downloaded, don't go asking for
13186 if (tp
->number_on_target
== 0)
13188 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", tp
->number_on_target
,
13189 phex_nz (loc
->address
, 0));
13191 reply
= remote_get_noisy_reply ();
13192 if (reply
&& *reply
)
13195 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13201 utp
->hit_count
= 0;
13202 utp
->traceframe_usage
= 0;
13203 xsnprintf (rs
->buf
.data (), size
, "qTP:%x:%s", utp
->number
,
13204 phex_nz (utp
->addr
, 0));
13206 reply
= remote_get_noisy_reply ();
13207 if (reply
&& *reply
)
13210 parse_tracepoint_status (reply
+ 1, bp
, utp
);
13216 remote_target::trace_stop ()
13218 struct remote_state
*rs
= get_remote_state ();
13221 remote_get_noisy_reply ();
13222 if (rs
->buf
[0] == '\0')
13223 error (_("Target does not support this command."));
13224 if (strcmp (rs
->buf
.data (), "OK") != 0)
13225 error (_("Bogus reply from target: %s"), rs
->buf
.data ());
13229 remote_target::trace_find (enum trace_find_type type
, int num
,
13230 CORE_ADDR addr1
, CORE_ADDR addr2
,
13233 struct remote_state
*rs
= get_remote_state ();
13234 char *endbuf
= rs
->buf
.data () + get_remote_packet_size ();
13236 int target_frameno
= -1, target_tracept
= -1;
13238 /* Lookups other than by absolute frame number depend on the current
13239 trace selected, so make sure it is correct on the remote end
13241 if (type
!= tfind_number
)
13242 set_remote_traceframe ();
13244 p
= rs
->buf
.data ();
13245 strcpy (p
, "QTFrame:");
13246 p
= strchr (p
, '\0');
13250 xsnprintf (p
, endbuf
- p
, "%x", num
);
13253 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
13256 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
13259 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
13260 phex_nz (addr2
, 0));
13262 case tfind_outside
:
13263 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
13264 phex_nz (addr2
, 0));
13267 error (_("Unknown trace find type %d"), type
);
13271 reply
= remote_get_noisy_reply ();
13272 if (*reply
== '\0')
13273 error (_("Target does not support this command."));
13275 while (reply
&& *reply
)
13280 target_frameno
= (int) strtol (p
, &reply
, 16);
13282 error (_("Unable to parse trace frame number"));
13283 /* Don't update our remote traceframe number cache on failure
13284 to select a remote traceframe. */
13285 if (target_frameno
== -1)
13290 target_tracept
= (int) strtol (p
, &reply
, 16);
13292 error (_("Unable to parse tracepoint number"));
13294 case 'O': /* "OK"? */
13295 if (reply
[1] == 'K' && reply
[2] == '\0')
13298 error (_("Bogus reply from target: %s"), reply
);
13301 error (_("Bogus reply from target: %s"), reply
);
13304 *tpp
= target_tracept
;
13306 rs
->remote_traceframe_number
= target_frameno
;
13307 return target_frameno
;
13311 remote_target::get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
13313 struct remote_state
*rs
= get_remote_state ();
13317 set_remote_traceframe ();
13319 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTV:%x", tsvnum
);
13321 reply
= remote_get_noisy_reply ();
13322 if (reply
&& *reply
)
13326 unpack_varlen_hex (reply
+ 1, &uval
);
13327 *val
= (LONGEST
) uval
;
13335 remote_target::save_trace_data (const char *filename
)
13337 struct remote_state
*rs
= get_remote_state ();
13340 p
= rs
->buf
.data ();
13341 strcpy (p
, "QTSave:");
13343 if ((p
- rs
->buf
.data ()) + strlen (filename
) * 2
13344 >= get_remote_packet_size ())
13345 error (_("Remote file name too long for trace save packet"));
13346 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
13349 reply
= remote_get_noisy_reply ();
13350 if (*reply
== '\0')
13351 error (_("Target does not support this command."));
13352 if (strcmp (reply
, "OK") != 0)
13353 error (_("Bogus reply from target: %s"), reply
);
13357 /* This is basically a memory transfer, but needs to be its own packet
13358 because we don't know how the target actually organizes its trace
13359 memory, plus we want to be able to ask for as much as possible, but
13360 not be unhappy if we don't get as much as we ask for. */
13363 remote_target::get_raw_trace_data (gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
13365 struct remote_state
*rs
= get_remote_state ();
13370 p
= rs
->buf
.data ();
13371 strcpy (p
, "qTBuffer:");
13373 p
+= hexnumstr (p
, offset
);
13375 p
+= hexnumstr (p
, len
);
13379 reply
= remote_get_noisy_reply ();
13380 if (reply
&& *reply
)
13382 /* 'l' by itself means we're at the end of the buffer and
13383 there is nothing more to get. */
13387 /* Convert the reply into binary. Limit the number of bytes to
13388 convert according to our passed-in buffer size, rather than
13389 what was returned in the packet; if the target is
13390 unexpectedly generous and gives us a bigger reply than we
13391 asked for, we don't want to crash. */
13392 rslt
= hex2bin (reply
, buf
, len
);
13396 /* Something went wrong, flag as an error. */
13401 remote_target::set_disconnected_tracing (int val
)
13403 struct remote_state
*rs
= get_remote_state ();
13405 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
13409 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13410 "QTDisconnected:%x", val
);
13412 reply
= remote_get_noisy_reply ();
13413 if (*reply
== '\0')
13414 error (_("Target does not support this command."));
13415 if (strcmp (reply
, "OK") != 0)
13416 error (_("Bogus reply from target: %s"), reply
);
13419 warning (_("Target does not support disconnected tracing."));
13423 remote_target::core_of_thread (ptid_t ptid
)
13425 struct thread_info
*info
= find_thread_ptid (ptid
);
13427 if (info
!= NULL
&& info
->priv
!= NULL
)
13428 return get_remote_thread_info (info
)->core
;
13434 remote_target::set_circular_trace_buffer (int val
)
13436 struct remote_state
*rs
= get_remote_state ();
13439 xsnprintf (rs
->buf
.data (), get_remote_packet_size (),
13440 "QTBuffer:circular:%x", val
);
13442 reply
= remote_get_noisy_reply ();
13443 if (*reply
== '\0')
13444 error (_("Target does not support this command."));
13445 if (strcmp (reply
, "OK") != 0)
13446 error (_("Bogus reply from target: %s"), reply
);
13450 remote_target::traceframe_info ()
13452 gdb::optional
<gdb::char_vector
> text
13453 = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO
,
13456 return parse_traceframe_info (text
->data ());
13461 /* Handle the qTMinFTPILen packet. Returns the minimum length of
13462 instruction on which a fast tracepoint may be placed. Returns -1
13463 if the packet is not supported, and 0 if the minimum instruction
13464 length is unknown. */
13467 remote_target::get_min_fast_tracepoint_insn_len ()
13469 struct remote_state
*rs
= get_remote_state ();
13472 /* If we're not debugging a process yet, the IPA can't be
13474 if (!target_has_execution
)
13477 /* Make sure the remote is pointing at the right process. */
13478 set_general_process ();
13480 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "qTMinFTPILen");
13482 reply
= remote_get_noisy_reply ();
13483 if (*reply
== '\0')
13487 ULONGEST min_insn_len
;
13489 unpack_varlen_hex (reply
, &min_insn_len
);
13491 return (int) min_insn_len
;
13496 remote_target::set_trace_buffer_size (LONGEST val
)
13498 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13500 struct remote_state
*rs
= get_remote_state ();
13501 char *buf
= rs
->buf
.data ();
13502 char *endbuf
= buf
+ get_remote_packet_size ();
13503 enum packet_result result
;
13505 gdb_assert (val
>= 0 || val
== -1);
13506 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13507 /* Send -1 as literal "-1" to avoid host size dependency. */
13511 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13514 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13517 remote_get_noisy_reply ();
13518 result
= packet_ok (rs
->buf
,
13519 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13521 if (result
!= PACKET_OK
)
13522 warning (_("Bogus reply from target: %s"), rs
->buf
.data ());
13527 remote_target::set_trace_notes (const char *user
, const char *notes
,
13528 const char *stop_notes
)
13530 struct remote_state
*rs
= get_remote_state ();
13532 char *buf
= rs
->buf
.data ();
13533 char *endbuf
= buf
+ get_remote_packet_size ();
13536 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13539 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13540 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13546 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13547 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13553 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13554 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13558 /* Ensure the buffer is terminated. */
13562 reply
= remote_get_noisy_reply ();
13563 if (*reply
== '\0')
13566 if (strcmp (reply
, "OK") != 0)
13567 error (_("Bogus reply from target: %s"), reply
);
13573 remote_target::use_agent (bool use
)
13575 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13577 struct remote_state
*rs
= get_remote_state ();
13579 /* If the stub supports QAgent. */
13580 xsnprintf (rs
->buf
.data (), get_remote_packet_size (), "QAgent:%d", use
);
13582 getpkt (&rs
->buf
, 0);
13584 if (strcmp (rs
->buf
.data (), "OK") == 0)
13595 remote_target::can_use_agent ()
13597 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13600 struct btrace_target_info
13602 /* The ptid of the traced thread. */
13605 /* The obtained branch trace configuration. */
13606 struct btrace_config conf
;
13609 /* Reset our idea of our target's btrace configuration. */
13612 remote_btrace_reset (remote_state
*rs
)
13614 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13617 /* Synchronize the configuration with the target. */
13620 remote_target::btrace_sync_conf (const btrace_config
*conf
)
13622 struct packet_config
*packet
;
13623 struct remote_state
*rs
;
13624 char *buf
, *pos
, *endbuf
;
13626 rs
= get_remote_state ();
13627 buf
= rs
->buf
.data ();
13628 endbuf
= buf
+ get_remote_packet_size ();
13630 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13631 if (packet_config_support (packet
) == PACKET_ENABLE
13632 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13635 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13639 getpkt (&rs
->buf
, 0);
13641 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13643 if (buf
[0] == 'E' && buf
[1] == '.')
13644 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13646 error (_("Failed to configure the BTS buffer size."));
13649 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13652 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13653 if (packet_config_support (packet
) == PACKET_ENABLE
13654 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13657 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13661 getpkt (&rs
->buf
, 0);
13663 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13665 if (buf
[0] == 'E' && buf
[1] == '.')
13666 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13668 error (_("Failed to configure the trace buffer size."));
13671 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13675 /* Read the current thread's btrace configuration from the target and
13676 store it into CONF. */
13679 btrace_read_config (struct btrace_config
*conf
)
13681 gdb::optional
<gdb::char_vector
> xml
13682 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF
, "");
13684 parse_xml_btrace_conf (conf
, xml
->data ());
13687 /* Maybe reopen target btrace. */
13690 remote_target::remote_btrace_maybe_reopen ()
13692 struct remote_state
*rs
= get_remote_state ();
13693 int btrace_target_pushed
= 0;
13694 #if !defined (HAVE_LIBIPT)
13698 scoped_restore_current_thread restore_thread
;
13700 for (thread_info
*tp
: all_non_exited_threads ())
13702 set_general_thread (tp
->ptid
);
13704 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13705 btrace_read_config (&rs
->btrace_config
);
13707 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13710 #if !defined (HAVE_LIBIPT)
13711 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13716 warning (_("Target is recording using Intel Processor Trace "
13717 "but support was disabled at compile time."));
13722 #endif /* !defined (HAVE_LIBIPT) */
13724 /* Push target, once, but before anything else happens. This way our
13725 changes to the threads will be cleaned up by unpushing the target
13726 in case btrace_read_config () throws. */
13727 if (!btrace_target_pushed
)
13729 btrace_target_pushed
= 1;
13730 record_btrace_push_target ();
13731 printf_filtered (_("Target is recording using %s.\n"),
13732 btrace_format_string (rs
->btrace_config
.format
));
13735 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13736 tp
->btrace
.target
->ptid
= tp
->ptid
;
13737 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13741 /* Enable branch tracing. */
13743 struct btrace_target_info
*
13744 remote_target::enable_btrace (ptid_t ptid
, const struct btrace_config
*conf
)
13746 struct btrace_target_info
*tinfo
= NULL
;
13747 struct packet_config
*packet
= NULL
;
13748 struct remote_state
*rs
= get_remote_state ();
13749 char *buf
= rs
->buf
.data ();
13750 char *endbuf
= buf
+ get_remote_packet_size ();
13752 switch (conf
->format
)
13754 case BTRACE_FORMAT_BTS
:
13755 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13758 case BTRACE_FORMAT_PT
:
13759 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13763 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13764 error (_("Target does not support branch tracing."));
13766 btrace_sync_conf (conf
);
13768 set_general_thread (ptid
);
13770 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13772 getpkt (&rs
->buf
, 0);
13774 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13776 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13777 error (_("Could not enable branch tracing for %s: %s"),
13778 target_pid_to_str (ptid
).c_str (), &rs
->buf
[2]);
13780 error (_("Could not enable branch tracing for %s."),
13781 target_pid_to_str (ptid
).c_str ());
13784 tinfo
= XCNEW (struct btrace_target_info
);
13785 tinfo
->ptid
= ptid
;
13787 /* If we fail to read the configuration, we lose some information, but the
13788 tracing itself is not impacted. */
13791 btrace_read_config (&tinfo
->conf
);
13793 catch (const gdb_exception_error
&err
)
13795 if (err
.message
!= NULL
)
13796 warning ("%s", err
.what ());
13802 /* Disable branch tracing. */
13805 remote_target::disable_btrace (struct btrace_target_info
*tinfo
)
13807 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13808 struct remote_state
*rs
= get_remote_state ();
13809 char *buf
= rs
->buf
.data ();
13810 char *endbuf
= buf
+ get_remote_packet_size ();
13812 if (packet_config_support (packet
) != PACKET_ENABLE
)
13813 error (_("Target does not support branch tracing."));
13815 set_general_thread (tinfo
->ptid
);
13817 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13819 getpkt (&rs
->buf
, 0);
13821 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13823 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13824 error (_("Could not disable branch tracing for %s: %s"),
13825 target_pid_to_str (tinfo
->ptid
).c_str (), &rs
->buf
[2]);
13827 error (_("Could not disable branch tracing for %s."),
13828 target_pid_to_str (tinfo
->ptid
).c_str ());
13834 /* Teardown branch tracing. */
13837 remote_target::teardown_btrace (struct btrace_target_info
*tinfo
)
13839 /* We must not talk to the target during teardown. */
13843 /* Read the branch trace. */
13846 remote_target::read_btrace (struct btrace_data
*btrace
,
13847 struct btrace_target_info
*tinfo
,
13848 enum btrace_read_type type
)
13850 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13853 if (packet_config_support (packet
) != PACKET_ENABLE
)
13854 error (_("Target does not support branch tracing."));
13856 #if !defined(HAVE_LIBEXPAT)
13857 error (_("Cannot process branch tracing result. XML parsing not supported."));
13862 case BTRACE_READ_ALL
:
13865 case BTRACE_READ_NEW
:
13868 case BTRACE_READ_DELTA
:
13872 internal_error (__FILE__
, __LINE__
,
13873 _("Bad branch tracing read type: %u."),
13874 (unsigned int) type
);
13877 gdb::optional
<gdb::char_vector
> xml
13878 = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE
, annex
);
13880 return BTRACE_ERR_UNKNOWN
;
13882 parse_xml_btrace (btrace
, xml
->data ());
13884 return BTRACE_ERR_NONE
;
13887 const struct btrace_config
*
13888 remote_target::btrace_conf (const struct btrace_target_info
*tinfo
)
13890 return &tinfo
->conf
;
13894 remote_target::augmented_libraries_svr4_read ()
13896 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13900 /* Implementation of to_load. */
13903 remote_target::load (const char *name
, int from_tty
)
13905 generic_load (name
, from_tty
);
13908 /* Accepts an integer PID; returns a string representing a file that
13909 can be opened on the remote side to get the symbols for the child
13910 process. Returns NULL if the operation is not supported. */
13913 remote_target::pid_to_exec_file (int pid
)
13915 static gdb::optional
<gdb::char_vector
> filename
;
13916 struct inferior
*inf
;
13917 char *annex
= NULL
;
13919 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13922 inf
= find_inferior_pid (pid
);
13924 internal_error (__FILE__
, __LINE__
,
13925 _("not currently attached to process %d"), pid
);
13927 if (!inf
->fake_pid_p
)
13929 const int annex_size
= 9;
13931 annex
= (char *) alloca (annex_size
);
13932 xsnprintf (annex
, annex_size
, "%x", pid
);
13935 filename
= target_read_stralloc (current_top_target (),
13936 TARGET_OBJECT_EXEC_FILE
, annex
);
13938 return filename
? filename
->data () : nullptr;
13941 /* Implement the to_can_do_single_step target_ops method. */
13944 remote_target::can_do_single_step ()
13946 /* We can only tell whether target supports single step or not by
13947 supported s and S vCont actions if the stub supports vContSupported
13948 feature. If the stub doesn't support vContSupported feature,
13949 we have conservatively to think target doesn't supports single
13951 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13953 struct remote_state
*rs
= get_remote_state ();
13955 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13956 remote_vcont_probe ();
13958 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13964 /* Implementation of the to_execution_direction method for the remote
13967 enum exec_direction_kind
13968 remote_target::execution_direction ()
13970 struct remote_state
*rs
= get_remote_state ();
13972 return rs
->last_resume_exec_dir
;
13975 /* Return pointer to the thread_info struct which corresponds to
13976 THREAD_HANDLE (having length HANDLE_LEN). */
13979 remote_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
13983 for (thread_info
*tp
: all_non_exited_threads ())
13985 remote_thread_info
*priv
= get_remote_thread_info (tp
);
13987 if (tp
->inf
== inf
&& priv
!= NULL
)
13989 if (handle_len
!= priv
->thread_handle
.size ())
13990 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13991 handle_len
, priv
->thread_handle
.size ());
13992 if (memcmp (thread_handle
, priv
->thread_handle
.data (),
14002 remote_target::can_async_p ()
14004 struct remote_state
*rs
= get_remote_state ();
14006 /* We don't go async if the user has explicitly prevented it with the
14007 "maint set target-async" command. */
14008 if (!target_async_permitted
)
14011 /* We're async whenever the serial device is. */
14012 return serial_can_async_p (rs
->remote_desc
);
14016 remote_target::is_async_p ()
14018 struct remote_state
*rs
= get_remote_state ();
14020 if (!target_async_permitted
)
14021 /* We only enable async when the user specifically asks for it. */
14024 /* We're async whenever the serial device is. */
14025 return serial_is_async_p (rs
->remote_desc
);
14028 /* Pass the SERIAL event on and up to the client. One day this code
14029 will be able to delay notifying the client of an event until the
14030 point where an entire packet has been received. */
14032 static serial_event_ftype remote_async_serial_handler
;
14035 remote_async_serial_handler (struct serial
*scb
, void *context
)
14037 /* Don't propogate error information up to the client. Instead let
14038 the client find out about the error by querying the target. */
14039 inferior_event_handler (INF_REG_EVENT
, NULL
);
14043 remote_async_inferior_event_handler (gdb_client_data data
)
14045 inferior_event_handler (INF_REG_EVENT
, data
);
14049 remote_target::async (int enable
)
14051 struct remote_state
*rs
= get_remote_state ();
14055 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
14057 /* If there are pending events in the stop reply queue tell the
14058 event loop to process them. */
14059 if (!rs
->stop_reply_queue
.empty ())
14060 mark_async_event_handler (rs
->remote_async_inferior_event_token
);
14061 /* For simplicity, below we clear the pending events token
14062 without remembering whether it is marked, so here we always
14063 mark it. If there's actually no pending notification to
14064 process, this ends up being a no-op (other than a spurious
14065 event-loop wakeup). */
14066 if (target_is_non_stop_p ())
14067 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14071 serial_async (rs
->remote_desc
, NULL
, NULL
);
14072 /* If the core is disabling async, it doesn't want to be
14073 disturbed with target events. Clear all async event sources
14075 clear_async_event_handler (rs
->remote_async_inferior_event_token
);
14076 if (target_is_non_stop_p ())
14077 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
14081 /* Implementation of the to_thread_events method. */
14084 remote_target::thread_events (int enable
)
14086 struct remote_state
*rs
= get_remote_state ();
14087 size_t size
= get_remote_packet_size ();
14089 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
14092 xsnprintf (rs
->buf
.data (), size
, "QThreadEvents:%x", enable
? 1 : 0);
14094 getpkt (&rs
->buf
, 0);
14096 switch (packet_ok (rs
->buf
,
14097 &remote_protocol_packets
[PACKET_QThreadEvents
]))
14100 if (strcmp (rs
->buf
.data (), "OK") != 0)
14101 error (_("Remote refused setting thread events: %s"), rs
->buf
.data ());
14104 warning (_("Remote failure reply: %s"), rs
->buf
.data ());
14106 case PACKET_UNKNOWN
:
14112 set_remote_cmd (const char *args
, int from_tty
)
14114 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
14118 show_remote_cmd (const char *args
, int from_tty
)
14120 /* We can't just use cmd_show_list here, because we want to skip
14121 the redundant "show remote Z-packet" and the legacy aliases. */
14122 struct cmd_list_element
*list
= remote_show_cmdlist
;
14123 struct ui_out
*uiout
= current_uiout
;
14125 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
14126 for (; list
!= NULL
; list
= list
->next
)
14127 if (strcmp (list
->name
, "Z-packet") == 0)
14129 else if (list
->type
== not_set_cmd
)
14130 /* Alias commands are exactly like the original, except they
14131 don't have the normal type. */
14135 ui_out_emit_tuple
option_emitter (uiout
, "option");
14137 uiout
->field_string ("name", list
->name
);
14138 uiout
->text (": ");
14139 if (list
->type
== show_cmd
)
14140 do_show_command (NULL
, from_tty
, list
);
14142 cmd_func (list
, NULL
, from_tty
);
14147 /* Function to be called whenever a new objfile (shlib) is detected. */
14149 remote_new_objfile (struct objfile
*objfile
)
14151 remote_target
*remote
= get_current_remote_target ();
14153 if (remote
!= NULL
) /* Have a remote connection. */
14154 remote
->remote_check_symbols ();
14157 /* Pull all the tracepoints defined on the target and create local
14158 data structures representing them. We don't want to create real
14159 tracepoints yet, we don't want to mess up the user's existing
14163 remote_target::upload_tracepoints (struct uploaded_tp
**utpp
)
14165 struct remote_state
*rs
= get_remote_state ();
14168 /* Ask for a first packet of tracepoint definition. */
14170 getpkt (&rs
->buf
, 0);
14171 p
= rs
->buf
.data ();
14172 while (*p
&& *p
!= 'l')
14174 parse_tracepoint_definition (p
, utpp
);
14175 /* Ask for another packet of tracepoint definition. */
14177 getpkt (&rs
->buf
, 0);
14178 p
= rs
->buf
.data ();
14184 remote_target::upload_trace_state_variables (struct uploaded_tsv
**utsvp
)
14186 struct remote_state
*rs
= get_remote_state ();
14189 /* Ask for a first packet of variable definition. */
14191 getpkt (&rs
->buf
, 0);
14192 p
= rs
->buf
.data ();
14193 while (*p
&& *p
!= 'l')
14195 parse_tsv_definition (p
, utsvp
);
14196 /* Ask for another packet of variable definition. */
14198 getpkt (&rs
->buf
, 0);
14199 p
= rs
->buf
.data ();
14204 /* The "set/show range-stepping" show hook. */
14207 show_range_stepping (struct ui_file
*file
, int from_tty
,
14208 struct cmd_list_element
*c
,
14211 fprintf_filtered (file
,
14212 _("Debugger's willingness to use range stepping "
14213 "is %s.\n"), value
);
14216 /* Return true if the vCont;r action is supported by the remote
14220 remote_target::vcont_r_supported ()
14222 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
14223 remote_vcont_probe ();
14225 return (packet_support (PACKET_vCont
) == PACKET_ENABLE
14226 && get_remote_state ()->supports_vCont
.r
);
14229 /* The "set/show range-stepping" set hook. */
14232 set_range_stepping (const char *ignore_args
, int from_tty
,
14233 struct cmd_list_element
*c
)
14235 /* When enabling, check whether range stepping is actually supported
14236 by the target, and warn if not. */
14237 if (use_range_stepping
)
14239 remote_target
*remote
= get_current_remote_target ();
14241 || !remote
->vcont_r_supported ())
14242 warning (_("Range stepping is not supported by the current target"));
14247 _initialize_remote (void)
14249 struct cmd_list_element
*cmd
;
14250 const char *cmd_name
;
14252 /* architecture specific data */
14253 remote_g_packet_data_handle
=
14254 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14257 = register_program_space_data_with_cleanup (NULL
,
14258 remote_pspace_data_cleanup
);
14260 add_target (remote_target_info
, remote_target::open
);
14261 add_target (extended_remote_target_info
, extended_remote_target::open
);
14263 /* Hook into new objfile notification. */
14264 gdb::observers::new_objfile
.attach (remote_new_objfile
);
14267 init_remote_threadtests ();
14270 /* set/show remote ... */
14272 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14273 Remote protocol specific variables\n\
14274 Configure various remote-protocol specific variables such as\n\
14275 the packets being used"),
14276 &remote_set_cmdlist
, "set remote ",
14277 0 /* allow-unknown */, &setlist
);
14278 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14279 Remote protocol specific variables\n\
14280 Configure various remote-protocol specific variables such as\n\
14281 the packets being used"),
14282 &remote_show_cmdlist
, "show remote ",
14283 0 /* allow-unknown */, &showlist
);
14285 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14286 Compare section data on target to the exec file.\n\
14287 Argument is a single section name (default: all loaded sections).\n\
14288 To compare only read-only loaded sections, specify the -r option."),
14291 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14292 Send an arbitrary packet to a remote target.\n\
14293 maintenance packet TEXT\n\
14294 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14295 this command sends the string TEXT to the inferior, and displays the\n\
14296 response packet. GDB supplies the initial `$' character, and the\n\
14297 terminating `#' character and checksum."),
14300 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14301 Set whether to send break if interrupted."), _("\
14302 Show whether to send break if interrupted."), _("\
14303 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14304 set_remotebreak
, show_remotebreak
,
14305 &setlist
, &showlist
);
14306 cmd_name
= "remotebreak";
14307 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14308 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14309 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14310 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14311 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14313 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14314 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14316 Set interrupt sequence to remote target."), _("\
14317 Show interrupt sequence to remote target."), _("\
14318 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14319 NULL
, show_interrupt_sequence
,
14320 &remote_set_cmdlist
,
14321 &remote_show_cmdlist
);
14323 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14324 &interrupt_on_connect
, _("\
14325 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14326 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14327 If set, interrupt sequence is sent to remote target."),
14329 &remote_set_cmdlist
, &remote_show_cmdlist
);
14331 /* Install commands for configuring memory read/write packets. */
14333 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14334 Set the maximum number of bytes per memory write packet (deprecated)."),
14336 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14337 Show the maximum number of bytes per memory write packet (deprecated)."),
14339 add_cmd ("memory-write-packet-size", no_class
,
14340 set_memory_write_packet_size
, _("\
14341 Set the maximum number of bytes per memory-write packet.\n\
14342 Specify the number of bytes in a packet or 0 (zero) for the\n\
14343 default packet size. The actual limit is further reduced\n\
14344 dependent on the target. Specify ``fixed'' to disable the\n\
14345 further restriction and ``limit'' to enable that restriction."),
14346 &remote_set_cmdlist
);
14347 add_cmd ("memory-read-packet-size", no_class
,
14348 set_memory_read_packet_size
, _("\
14349 Set the maximum number of bytes per memory-read packet.\n\
14350 Specify the number of bytes in a packet or 0 (zero) for the\n\
14351 default packet size. The actual limit is further reduced\n\
14352 dependent on the target. Specify ``fixed'' to disable the\n\
14353 further restriction and ``limit'' to enable that restriction."),
14354 &remote_set_cmdlist
);
14355 add_cmd ("memory-write-packet-size", no_class
,
14356 show_memory_write_packet_size
,
14357 _("Show the maximum number of bytes per memory-write packet."),
14358 &remote_show_cmdlist
);
14359 add_cmd ("memory-read-packet-size", no_class
,
14360 show_memory_read_packet_size
,
14361 _("Show the maximum number of bytes per memory-read packet."),
14362 &remote_show_cmdlist
);
14364 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class
,
14365 &remote_hw_watchpoint_limit
, _("\
14366 Set the maximum number of target hardware watchpoints."), _("\
14367 Show the maximum number of target hardware watchpoints."), _("\
14368 Specify \"unlimited\" for unlimited hardware watchpoints."),
14369 NULL
, show_hardware_watchpoint_limit
,
14370 &remote_set_cmdlist
,
14371 &remote_show_cmdlist
);
14372 add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14374 &remote_hw_watchpoint_length_limit
, _("\
14375 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14376 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14377 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14378 NULL
, show_hardware_watchpoint_length_limit
,
14379 &remote_set_cmdlist
, &remote_show_cmdlist
);
14380 add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class
,
14381 &remote_hw_breakpoint_limit
, _("\
14382 Set the maximum number of target hardware breakpoints."), _("\
14383 Show the maximum number of target hardware breakpoints."), _("\
14384 Specify \"unlimited\" for unlimited hardware breakpoints."),
14385 NULL
, show_hardware_breakpoint_limit
,
14386 &remote_set_cmdlist
, &remote_show_cmdlist
);
14388 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14389 &remote_address_size
, _("\
14390 Set the maximum size of the address (in bits) in a memory packet."), _("\
14391 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14393 NULL
, /* FIXME: i18n: */
14394 &setlist
, &showlist
);
14396 init_all_packet_configs ();
14398 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14399 "X", "binary-download", 1);
14401 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14402 "vCont", "verbose-resume", 0);
14404 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14405 "QPassSignals", "pass-signals", 0);
14407 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14408 "QCatchSyscalls", "catch-syscalls", 0);
14410 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14411 "QProgramSignals", "program-signals", 0);
14413 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QSetWorkingDir
],
14414 "QSetWorkingDir", "set-working-dir", 0);
14416 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14417 "QStartupWithShell", "startup-with-shell", 0);
14419 add_packet_config_cmd (&remote_protocol_packets
14420 [PACKET_QEnvironmentHexEncoded
],
14421 "QEnvironmentHexEncoded", "environment-hex-encoded",
14424 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14425 "QEnvironmentReset", "environment-reset",
14428 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14429 "QEnvironmentUnset", "environment-unset",
14432 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14433 "qSymbol", "symbol-lookup", 0);
14435 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14436 "P", "set-register", 1);
14438 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14439 "p", "fetch-register", 1);
14441 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14442 "Z0", "software-breakpoint", 0);
14444 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14445 "Z1", "hardware-breakpoint", 0);
14447 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14448 "Z2", "write-watchpoint", 0);
14450 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14451 "Z3", "read-watchpoint", 0);
14453 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14454 "Z4", "access-watchpoint", 0);
14456 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14457 "qXfer:auxv:read", "read-aux-vector", 0);
14459 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14460 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14462 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14463 "qXfer:features:read", "target-features", 0);
14465 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14466 "qXfer:libraries:read", "library-info", 0);
14468 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14469 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14471 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14472 "qXfer:memory-map:read", "memory-map", 0);
14474 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
14475 "qXfer:spu:read", "read-spu-object", 0);
14477 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
14478 "qXfer:spu:write", "write-spu-object", 0);
14480 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14481 "qXfer:osdata:read", "osdata", 0);
14483 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14484 "qXfer:threads:read", "threads", 0);
14486 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14487 "qXfer:siginfo:read", "read-siginfo-object", 0);
14489 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14490 "qXfer:siginfo:write", "write-siginfo-object", 0);
14492 add_packet_config_cmd
14493 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14494 "qXfer:traceframe-info:read", "traceframe-info", 0);
14496 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14497 "qXfer:uib:read", "unwind-info-block", 0);
14499 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14500 "qGetTLSAddr", "get-thread-local-storage-address",
14503 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14504 "qGetTIBAddr", "get-thread-information-block-address",
14507 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14508 "bc", "reverse-continue", 0);
14510 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14511 "bs", "reverse-step", 0);
14513 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14514 "qSupported", "supported-packets", 0);
14516 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14517 "qSearch:memory", "search-memory", 0);
14519 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14520 "qTStatus", "trace-status", 0);
14522 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14523 "vFile:setfs", "hostio-setfs", 0);
14525 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14526 "vFile:open", "hostio-open", 0);
14528 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14529 "vFile:pread", "hostio-pread", 0);
14531 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14532 "vFile:pwrite", "hostio-pwrite", 0);
14534 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14535 "vFile:close", "hostio-close", 0);
14537 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14538 "vFile:unlink", "hostio-unlink", 0);
14540 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14541 "vFile:readlink", "hostio-readlink", 0);
14543 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14544 "vFile:fstat", "hostio-fstat", 0);
14546 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14547 "vAttach", "attach", 0);
14549 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14552 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14553 "QStartNoAckMode", "noack", 0);
14555 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14556 "vKill", "kill", 0);
14558 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14559 "qAttached", "query-attached", 0);
14561 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14562 "ConditionalTracepoints",
14563 "conditional-tracepoints", 0);
14565 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14566 "ConditionalBreakpoints",
14567 "conditional-breakpoints", 0);
14569 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14570 "BreakpointCommands",
14571 "breakpoint-commands", 0);
14573 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14574 "FastTracepoints", "fast-tracepoints", 0);
14576 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14577 "TracepointSource", "TracepointSource", 0);
14579 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14580 "QAllow", "allow", 0);
14582 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14583 "StaticTracepoints", "static-tracepoints", 0);
14585 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14586 "InstallInTrace", "install-in-trace", 0);
14588 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14589 "qXfer:statictrace:read", "read-sdata-object", 0);
14591 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14592 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14594 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14595 "QDisableRandomization", "disable-randomization", 0);
14597 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14598 "QAgent", "agent", 0);
14600 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14601 "QTBuffer:size", "trace-buffer-size", 0);
14603 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14604 "Qbtrace:off", "disable-btrace", 0);
14606 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14607 "Qbtrace:bts", "enable-btrace-bts", 0);
14609 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14610 "Qbtrace:pt", "enable-btrace-pt", 0);
14612 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14613 "qXfer:btrace", "read-btrace", 0);
14615 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14616 "qXfer:btrace-conf", "read-btrace-conf", 0);
14618 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14619 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14621 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14622 "multiprocess-feature", "multiprocess-feature", 0);
14624 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14625 "swbreak-feature", "swbreak-feature", 0);
14627 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14628 "hwbreak-feature", "hwbreak-feature", 0);
14630 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14631 "fork-event-feature", "fork-event-feature", 0);
14633 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14634 "vfork-event-feature", "vfork-event-feature", 0);
14636 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14637 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14639 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14640 "vContSupported", "verbose-resume-supported", 0);
14642 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14643 "exec-event-feature", "exec-event-feature", 0);
14645 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14646 "vCtrlC", "ctrl-c", 0);
14648 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14649 "QThreadEvents", "thread-events", 0);
14651 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14652 "N stop reply", "no-resumed-stop-reply", 0);
14654 /* Assert that we've registered "set remote foo-packet" commands
14655 for all packet configs. */
14659 for (i
= 0; i
< PACKET_MAX
; i
++)
14661 /* Ideally all configs would have a command associated. Some
14662 still don't though. */
14667 case PACKET_QNonStop
:
14668 case PACKET_EnableDisableTracepoints_feature
:
14669 case PACKET_tracenz_feature
:
14670 case PACKET_DisconnectedTracing_feature
:
14671 case PACKET_augmented_libraries_svr4_read_feature
:
14673 /* Additions to this list need to be well justified:
14674 pre-existing packets are OK; new packets are not. */
14682 /* This catches both forgetting to add a config command, and
14683 forgetting to remove a packet from the exception list. */
14684 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14688 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14689 Z sub-packet has its own set and show commands, but users may
14690 have sets to this variable in their .gdbinit files (or in their
14692 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14693 &remote_Z_packet_detect
, _("\
14694 Set use of remote protocol `Z' packets"), _("\
14695 Show use of remote protocol `Z' packets "), _("\
14696 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14698 set_remote_protocol_Z_packet_cmd
,
14699 show_remote_protocol_Z_packet_cmd
,
14700 /* FIXME: i18n: Use of remote protocol
14701 `Z' packets is %s. */
14702 &remote_set_cmdlist
, &remote_show_cmdlist
);
14704 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14705 Manipulate files on the remote system\n\
14706 Transfer files to and from the remote target system."),
14707 &remote_cmdlist
, "remote ",
14708 0 /* allow-unknown */, &cmdlist
);
14710 add_cmd ("put", class_files
, remote_put_command
,
14711 _("Copy a local file to the remote system."),
14714 add_cmd ("get", class_files
, remote_get_command
,
14715 _("Copy a remote file to the local system."),
14718 add_cmd ("delete", class_files
, remote_delete_command
,
14719 _("Delete a remote file."),
14722 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14723 &remote_exec_file_var
, _("\
14724 Set the remote pathname for \"run\""), _("\
14725 Show the remote pathname for \"run\""), NULL
,
14726 set_remote_exec_file
,
14727 show_remote_exec_file
,
14728 &remote_set_cmdlist
,
14729 &remote_show_cmdlist
);
14731 add_setshow_boolean_cmd ("range-stepping", class_run
,
14732 &use_range_stepping
, _("\
14733 Enable or disable range stepping."), _("\
14734 Show whether target-assisted range stepping is enabled."), _("\
14735 If on, and the target supports it, when stepping a source line, GDB\n\
14736 tells the target to step the corresponding range of addresses itself instead\n\
14737 of issuing multiple single-steps. This speeds up source level\n\
14738 stepping. If off, GDB always issues single-steps, even if range\n\
14739 stepping is supported by the target. The default is on."),
14740 set_range_stepping
,
14741 show_range_stepping
,
14745 /* Eventually initialize fileio. See fileio.c */
14746 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);